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




@is_pipeline_test
class        _SCREAMING_SNAKE_CASE	( 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        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase					)							->			int:
					lowerCamelCase_         =     ZeroShotClassificationPipeline(
					    model=lowercase		,    tokenizer=lowercase		,    candidate_labels=["polics", "health"]					)
					return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase					)							->			Any:
					lowerCamelCase_         =     classifier("Who are you voting for in 2020?"		,    candidate_labels="politics"					)
					self.assertEqual(lowercase		,    {"sequence": ANY(lowercase					), "labels": [ANY(lowercase					)], "scores": [ANY(lowercase					)]}					)

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

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

					lowerCamelCase_         =     classifier("Who are you voting for in 2020?"		,    candidate_labels="politics, public health"					)
					self.assertEqual(
					    lowercase		,    {"sequence": ANY(lowercase					), "labels": [ANY(lowercase					), ANY(lowercase					)], "scores": [ANY(lowercase					), ANY(lowercase					)]}					)
					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(
					    lowercase		,    {"sequence": ANY(lowercase					), "labels": [ANY(lowercase					), ANY(lowercase					)], "scores": [ANY(lowercase					), ANY(lowercase					)]}					)
					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(lowercase		,    {"sequence": ANY(lowercase					), "labels": [ANY(lowercase					)], "scores": [ANY(lowercase					)]}					)

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

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

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

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

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

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

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

					self.run_entailment_id(lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase					)							->			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(lowercase		,    zero_shot_classifier.entailment_id					)



	@require_torch
	def        SCREAMING_SNAKE_CASE_(       self					)							->			Union[str, Any]:
					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?" * 100		,    candidate_labels=["politics", "public health", "science"]					)



	@require_torch
	def        SCREAMING_SNAKE_CASE_(       self					)							->			Tuple:
					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(lowercase					)		,    {
					        "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        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[Any]:
					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(lowercase					)		,    {
					        "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        SCREAMING_SNAKE_CASE_(       self					)							->			int:
					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(lowercase					)		,    {
					        "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=lowercase		,    )
					self.assertEqual(
					    nested_simplify(lowercase					)		,    {
					        "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        SCREAMING_SNAKE_CASE_(       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(lowercase					)		,    {
					        "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=lowercase		,    )
					self.assertEqual(
					    nested_simplify(lowercase					)		,    {
					        "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 os

import torch

from transformers import (
    XLNetConfig,
    XLNetForQuestionAnswering,
    XLNetForSequenceClassification,
    XLNetLMHeadModel,
    load_tf_weights_in_xlnet,
)
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


__A							={
    '''cola''': 2,
    '''mnli''': 3,
    '''mrpc''': 2,
    '''sst-2''': 2,
    '''sts-b''': 1,
    '''qqp''': 2,
    '''qnli''': 2,
    '''rte''': 2,
    '''wnli''': 2,
}


logging.set_verbosity_info()





def      lowerCamelCase_					(							lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__=None       ):
				# Initialise PyTorch model
				lowerCamelCase_         =     XLNetConfig.from_json_file(lowerCamelCase__       )

				lowerCamelCase_         =     finetuning_task.lower() if finetuning_task is not None else ""
				if finetuning_task in GLUE_TASKS_NUM_LABELS:
								print(F'Building PyTorch XLNetForSequenceClassification model from configuration: {config}'       )
								lowerCamelCase_         =     finetuning_task
								lowerCamelCase_         =     GLUE_TASKS_NUM_LABELS[finetuning_task]
								lowerCamelCase_         =     XLNetForSequenceClassification(lowerCamelCase__       )
				elif "squad" in finetuning_task:
								lowerCamelCase_         =     finetuning_task
								lowerCamelCase_         =     XLNetForQuestionAnswering(lowerCamelCase__       )
				else:
								lowerCamelCase_         =     XLNetLMHeadModel(lowerCamelCase__       )

				# Load weights from tf checkpoint
				load_tf_weights_in_xlnet(lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__       )

				# Save pytorch-model
				lowerCamelCase_         =     os.path.join(lowerCamelCase__      ,					lowerCamelCase__       )
				lowerCamelCase_         =     os.path.join(lowerCamelCase__      ,					lowerCamelCase__       )
				print(F'Save PyTorch model to {os.path.abspath(lowerCamelCase__       )}'       )
				torch.save(model.state_dict()      ,					lowerCamelCase__       )
				print(F'Save configuration file to {os.path.abspath(lowerCamelCase__       )}'       )
				with open(lowerCamelCase__      ,					"w"      ,					encoding="utf-8"       ) as f:
								f.write(config.to_json_string()       )


if __name__ == "__main__":
			__A							=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(
			    '''--xlnet_config_file''',
			    default=None,
			    type=str,
			    required=True,
			    help=(
			        '''The config json file corresponding to the pre-trained XLNet model. \n'''
			        '''This specifies the model architecture.'''
			    ),
			)
			parser.add_argument(
			    '''--pytorch_dump_folder_path''',
			    default=None,
			    type=str,
			    required=True,
			    help='''Path to the folder to store the PyTorch model or dataset/vocab.''',
			)
			parser.add_argument(
			    '''--finetuning_task''',
			    default=None,
			    type=str,
			    help='''Name of a task on which the XLNet TensorFlow model was fine-tuned''',
			)
			__A							=parser.parse_args()
			print(args)

			convert_xlnet_checkpoint_to_pytorch(
			    args.tf_checkpoint_path, args.xlnet_config_file, args.pytorch_dump_folder_path, args.finetuning_task
			)


