

"""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.
SCREAMING_SNAKE_CASE__:str			=	{"""LayoutLMv2Config""", """LayoutLMv3Config"""}






@is_pipeline_test
class 				snake_case__     (   unittest.TestCase   ):
 _snake_case   :			List[str]           =		MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
 _snake_case   :			List[str]           =		TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

 if model_mapping is not None:
  _snake_case   :			int           =		{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   :			Union[str, Any]           =		{
      config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
  }


 def 		a__ (				self  ,						lowerCamelCase  ,						lowerCamelCase  ,						lowerCamelCase		):
        __a     				=  ZeroShotClassificationPipeline(
            model=lowerCamelCase  ,						tokenizer=lowerCamelCase  ,						candidate_labels=["polics", "health"]		)
        return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]


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

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

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

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

        __a     				=  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
        __a     				=  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		)
            ]  ,						)
        __a     				=  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 		a__ (				self  ,						lowerCamelCase		):
        __a     				=  zero_shot_classifier.model.config
        __a     				=  config.labelaid
        __a     				=  zero_shot_classifier.entailment_id

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

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

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

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

        __a     				=  original_labelaid
        self.assertEqual(lowerCamelCase  ,						zero_shot_classifier.entailment_id		)


 @require_torch
 def 		a__ (				self		):
        __a     				=  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 		a__ (				self		):
        __a     				=  pipeline(
            "zero-shot-classification"  ,						model="sshleifer/tiny-distilbert-base-cased-distilled-squad"  ,						framework="pt"  ,						)
        __a     				=  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.333, 0.333, 0.333],
            }  ,						)


 @require_tf
 def 		a__ (				self		):
        __a     				=  pipeline(
            "zero-shot-classification"  ,						model="sshleifer/tiny-distilbert-base-cased-distilled-squad"  ,						framework="tf"  ,						)
        __a     				=  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.333, 0.333, 0.333],
            }  ,						)


 @slow
 @require_torch
 def 		a__ (				self		):
        __a     				=  pipeline("zero-shot-classification"  ,						model="roberta-large-mnli"  ,						framework="pt"		)
        __a     				=  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.976, 0.015, 0.009],
            }  ,						)
        __a     				=  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.817, 0.713, 0.018, 0.018],
            }  ,						)






 @slow
 @require_tf
 def 		a__ (				self		):
        __a     				=  pipeline("zero-shot-classification"  ,						model="roberta-large-mnli"  ,						framework="tf"		)
        __a     				=  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.976, 0.015, 0.009],
            }  ,						)
        __a     				=  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.817, 0.713, 0.018, 0.018],
            }  ,						)

"""simple docstring"""



import argparse

import torch

from transformers import (
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaForAudioFrameClassification,
    WavaVecaForSequenceClassification,
    WavaVecaForXVector,
    logging,
)


logging.set_verbosity_info()
SCREAMING_SNAKE_CASE__:Dict			=	logging.get_logger(__name__)



def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  WavaVecaForSequenceClassification.from_pretrained(a ,  config=a							)
       __a     				=  downstream_dict["projector.weight"]
       __a     				=  downstream_dict["projector.bias"]
       __a     				=  downstream_dict["model.post_net.linear.weight"]
       __a     				=  downstream_dict["model.post_net.linear.bias"]
       return model



def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  WavaVecaForAudioFrameClassification.from_pretrained(a ,  config=a							)
       __a     				=  downstream_dict["model.linear.weight"]
       __a     				=  downstream_dict["model.linear.bias"]
       return model



def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  WavaVecaForXVector.from_pretrained(a ,  config=a							)
       __a     				=  downstream_dict["connector.weight"]
       __a     				=  downstream_dict["connector.bias"]
       for i, kernel_size in enumerate(hf_config.tdnn_kernel							):
              __a     				=  downstream_dict[
                  F"model.framelevel_feature_extractor.module.{i}.kernel.weight"
              ]
              __a     				=  downstream_dict[F"model.framelevel_feature_extractor.module.{i}.kernel.bias"]

       __a     				=  downstream_dict["model.utterancelevel_feature_extractor.linear1.weight"]
       __a     				=  downstream_dict["model.utterancelevel_feature_extractor.linear1.bias"]
       __a     				=  downstream_dict["model.utterancelevel_feature_extractor.linear2.weight"]
       __a     				=  downstream_dict["model.utterancelevel_feature_extractor.linear2.bias"]
       __a     				=  downstream_dict["objective.W"]
       return model



@torch.no_grad()
def 					_lowerCamelCase(					a ,  a ,  a ,  a							):
       __a     				=  torch.load(a ,  map_location="cpu"							)

       __a     				=  checkpoint["Downstream"]

       __a     				=  WavaVecaConfig.from_pretrained(a							)
       __a     				=  WavaVecaFeatureExtractor.from_pretrained(
           a ,  return_attention_mask=a ,  do_normalize=a							)

       __a     				=  hf_config.architectures[0]
       if arch.endswith("ForSequenceClassification"							):
              __a     				=  convert_classification(a ,  a ,  a							)
       elif arch.endswith("ForAudioFrameClassification"							):
              __a     				=  convert_diarization(a ,  a ,  a							)
       elif arch.endswith("ForXVector"							):
              __a     				=  convert_xvector(a ,  a ,  a							)
       else:
              raise NotImplementedError(F"S3PRL weights conversion is not supported for {arch}"							)

       if hf_config.use_weighted_layer_sum:
              __a     				=  checkpoint["Featurizer"]["weights"]

       hf_feature_extractor.save_pretrained(a							)
       hf_model.save_pretrained(a							)


if __name__ == "__main__":
   SCREAMING_SNAKE_CASE__:Union[str, Any]			=	argparse.ArgumentParser()
   parser.add_argument(
       """--base_model_name""", default=None, type=str, help="""Name of the huggingface pretrained base model."""
   )
   parser.add_argument("""--config_path""", default=None, type=str, help="""Path to the huggingface classifier config.""")
   parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to the s3prl checkpoint.""")
   parser.add_argument("""--model_dump_path""", default=None, type=str, help="""Path to the final converted model.""")
   SCREAMING_SNAKE_CASE__:Any			=	parser.parse_args()
   convert_saprl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)
