
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


lowerCamelCase_						     =					{
    '''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 						__magic_name__			(   __a      :	List[Any]	,		__a      :	List[str]	,		__a      :	int	,		__a      :	Optional[int]=None						):



     '''simple docstring'''




     UpperCamelCase__				=    XLNetConfig.from_json_file(__a						)

     UpperCamelCase__				=    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}"						)
          UpperCamelCase__				=    finetuning_task
          UpperCamelCase__				=    GLUE_TASKS_NUM_LABELS[finetuning_task]
          UpperCamelCase__				=    XLNetForSequenceClassification(__a						)
     elif "squad" in finetuning_task:
          UpperCamelCase__				=    finetuning_task
          UpperCamelCase__				=    XLNetForQuestionAnswering(__a						)
     else:
          UpperCamelCase__				=    XLNetLMHeadModel(__a						)

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

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


if __name__ == "__main__":
    lowerCamelCase_						     =					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''',
    )
    lowerCamelCase_						     =					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
    )







import hashlib
import unittest
from typing import Dict

import numpy as np

from transformers import (
    MODEL_FOR_MASK_GENERATION_MAPPING,
    TF_MODEL_FOR_MASK_GENERATION_MAPPING,
    is_vision_available,
    pipeline,
)
from transformers.pipelines import MaskGenerationPipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)


if is_vision_available():
    from PIL import Image
else:




    class      __A:

      """simple docstring"""







      @staticmethod
      def 	UpperCAmelCase_ (*SCREAMING_SNAKE_CASE_	,      **SCREAMING_SNAKE_CASE_						):
           pass






def 						__magic_name__			(   __a      :	Image						):



     '''simple docstring'''




     UpperCamelCase__				=    hashlib.mda(image.tobytes()						)
     return m.hexdigest()[:10]






def 						__magic_name__			(   __a      :	Image						):



     '''simple docstring'''




     UpperCamelCase__				=    np.array(__a						)
     UpperCamelCase__				=    npimg.shape
     return {"hash": hashimage(__a						), "shape": shape}




@is_pipeline_test
@require_vision
@require_torch
class      __A(    unittest.TestCase			):

  """simple docstring"""
  SCREAMING_SNAKE_CASE__         =      dict(
      (list(MODEL_FOR_MASK_GENERATION_MAPPING.items()			) if MODEL_FOR_MASK_GENERATION_MAPPING else [])			)
  SCREAMING_SNAKE_CASE__         =      dict(
      (list(TF_MODEL_FOR_MASK_GENERATION_MAPPING.items()			) if TF_MODEL_FOR_MASK_GENERATION_MAPPING else [])			)







  def 	UpperCAmelCase_ (self	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						):
       UpperCamelCase__				=    MaskGenerationPipeline(model=SCREAMING_SNAKE_CASE_	,      image_processor=SCREAMING_SNAKE_CASE_						)
       return image_segmenter, [
           "./tests/fixtures/tests_samples/COCO/000000039769.png",
           "./tests/fixtures/tests_samples/COCO/000000039769.png",
       ]







  def 	UpperCAmelCase_ (self	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						):
       pass







  @require_tf
  @unittest.skip("""Image segmentation not implemented in TF"""						)
  def 	UpperCAmelCase_ (self						):
       pass







  @slow
  @require_torch
  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    pipeline("""mask-generation"""	,      model="""facebook/sam-vit-huge"""						)

       UpperCamelCase__				=    image_segmenter("""http://images.cocodataset.org/val2017/000000039769.jpg"""	,      points_per_batch=2_56						)

       # Shortening by hashing
       UpperCamelCase__				=    []
       for i, o in enumerate(outputs["""masks"""]						):
            new_outupt += [{"mask": mask_to_test_readable(SCREAMING_SNAKE_CASE_						), "scores": outputs["scores"][i]}]

       # fmt: off
       self.assertEqual(
           nested_simplify(SCREAMING_SNAKE_CASE_	,      decimals=4						)	,      [
               {"""mask""": {"""hash""": """115ad19f5f""", """shape""": (4_80, 6_40)}, """scores""": 1.0444},
               {"""mask""": {"""hash""": """6affa964c6""", """shape""": (4_80, 6_40)}, """scores""": 1.021},
               {"""mask""": {"""hash""": """dfe28a0388""", """shape""": (4_80, 6_40)}, """scores""": 1.0167},
               {"""mask""": {"""hash""": """c0a5f4a318""", """shape""": (4_80, 6_40)}, """scores""": 1.0132},
               {"""mask""": {"""hash""": """fe8065c197""", """shape""": (4_80, 6_40)}, """scores""": 1.0053},
               {"""mask""": {"""hash""": """e2d0b7a0b7""", """shape""": (4_80, 6_40)}, """scores""": 0.9967},
               {"""mask""": {"""hash""": """453c7844bd""", """shape""": (4_80, 6_40)}, """scores""": 0.993},
               {"""mask""": {"""hash""": """3d44f2926d""", """shape""": (4_80, 6_40)}, """scores""": 0.9909},
               {"""mask""": {"""hash""": """64033ddc3f""", """shape""": (4_80, 6_40)}, """scores""": 0.9879},
               {"""mask""": {"""hash""": """801064ff79""", """shape""": (4_80, 6_40)}, """scores""": 0.9834},
               {"""mask""": {"""hash""": """6172f276ef""", """shape""": (4_80, 6_40)}, """scores""": 0.9716},
               {"""mask""": {"""hash""": """b49e60e084""", """shape""": (4_80, 6_40)}, """scores""": 0.9612},
               {"""mask""": {"""hash""": """a811e775fd""", """shape""": (4_80, 6_40)}, """scores""": 0.9599},
               {"""mask""": {"""hash""": """a6a8ebcf4b""", """shape""": (4_80, 6_40)}, """scores""": 0.9552},
               {"""mask""": {"""hash""": """9d8257e080""", """shape""": (4_80, 6_40)}, """scores""": 0.9532},
               {"""mask""": {"""hash""": """32de6454a8""", """shape""": (4_80, 6_40)}, """scores""": 0.9516},
               {"""mask""": {"""hash""": """af3d4af2c8""", """shape""": (4_80, 6_40)}, """scores""": 0.9499},
               {"""mask""": {"""hash""": """3c6db475fb""", """shape""": (4_80, 6_40)}, """scores""": 0.9483},
               {"""mask""": {"""hash""": """c290813fb9""", """shape""": (4_80, 6_40)}, """scores""": 0.9464},
               {"""mask""": {"""hash""": """b6f0b8f606""", """shape""": (4_80, 6_40)}, """scores""": 0.943},
               {"""mask""": {"""hash""": """92ce16bfdf""", """shape""": (4_80, 6_40)}, """scores""": 0.943},
               {"""mask""": {"""hash""": """c749b25868""", """shape""": (4_80, 6_40)}, """scores""": 0.9408},
               {"""mask""": {"""hash""": """efb6cab859""", """shape""": (4_80, 6_40)}, """scores""": 0.9335},
               {"""mask""": {"""hash""": """1ff2eafb30""", """shape""": (4_80, 6_40)}, """scores""": 0.9326},
               {"""mask""": {"""hash""": """788b798e24""", """shape""": (4_80, 6_40)}, """scores""": 0.9262},
               {"""mask""": {"""hash""": """abea804f0e""", """shape""": (4_80, 6_40)}, """scores""": 0.8999},
               {"""mask""": {"""hash""": """7b9e8ddb73""", """shape""": (4_80, 6_40)}, """scores""": 0.8986},
               {"""mask""": {"""hash""": """cd24047c8a""", """shape""": (4_80, 6_40)}, """scores""": 0.8984},
               {"""mask""": {"""hash""": """6943e6bcbd""", """shape""": (4_80, 6_40)}, """scores""": 0.8873},
               {"""mask""": {"""hash""": """b5f47c9191""", """shape""": (4_80, 6_40)}, """scores""": 0.8871}
           ]	,      )
       # fmt: on







  @require_torch
  @slow
  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    """facebook/sam-vit-huge"""
       UpperCamelCase__				=    pipeline("""mask-generation"""	,      model=SCREAMING_SNAKE_CASE_						)

       UpperCamelCase__				=    image_segmenter(
           """http://images.cocodataset.org/val2017/000000039769.jpg"""	,      pred_iou_thresh=1	,      points_per_batch=2_56						)

       # Shortening by hashing
       UpperCamelCase__				=    []
       for i, o in enumerate(outputs["""masks"""]						):
            new_outupt += [{"mask": mask_to_test_readable(SCREAMING_SNAKE_CASE_						), "scores": outputs["scores"][i]}]

       self.assertEqual(
           nested_simplify(SCREAMING_SNAKE_CASE_	,      decimals=4						)	,      [
               {"""mask""": {"""hash""": """115ad19f5f""", """shape""": (4_80, 6_40)}, """scores""": 1.0444},
               {"""mask""": {"""hash""": """6affa964c6""", """shape""": (4_80, 6_40)}, """scores""": 1.0210},
               {"""mask""": {"""hash""": """dfe28a0388""", """shape""": (4_80, 6_40)}, """scores""": 1.0167},
               {"""mask""": {"""hash""": """c0a5f4a318""", """shape""": (4_80, 6_40)}, """scores""": 1.0132},
               {"""mask""": {"""hash""": """fe8065c197""", """shape""": (4_80, 6_40)}, """scores""": 1.0053},
           ]	,      )





