



'''simple docstring'''






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: Optional[int]							=						{
    '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__	(						_A			,      _A			,      _A			,      _A=None    ):
  # Initialise PyTorch model
  a						: Optional[int]					       =					XLNetConfig.from_json_file(_A    )

  a						: Tuple					       =					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}"""    )
    a						: Any					       =					finetuning_task
    a						: Union[str, Any]					       =					GLUE_TASKS_NUM_LABELS[finetuning_task]
    a						: str					       =					XLNetForSequenceClassification(_A    )
  elif "squad" in finetuning_task:
    a						: str					       =					finetuning_task
    a						: Union[str, Any]					       =					XLNetForQuestionAnswering(_A    )
  else:
    a						: Optional[int]					       =					XLNetLMHeadModel(_A    )

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

  # Save pytorch-model
  a						: Dict					       =					os.path.join(_A			,      _A    )
  a						: Union[str, Any]					       =					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: str							=						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: Any							=						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
     )




'''simple docstring'''






import argparse

from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection

from diffusers import UnCLIPImageVariationPipeline, UnCLIPPipeline


if __name__ == "__main__":
     lowerCAmelCase: Any							=						argparse.ArgumentParser()

     parser.add_argument('--dump_path', default=None, type=str, required=True, help='Path to the output model.')

     parser.add_argument(
         '--txt2img_unclip',
         default='kakaobrain/karlo-v1-alpha',
         type=str,
         required=False,
         help='The pretrained txt2img unclip.',
     )

     lowerCAmelCase: Optional[int]							=						parser.parse_args()

     lowerCAmelCase: List[Any]							=						UnCLIPPipeline.from_pretrained(args.txtaimg_unclip)

     lowerCAmelCase: Optional[Any]							=						CLIPImageProcessor()
     lowerCAmelCase: Tuple							=						CLIPVisionModelWithProjection.from_pretrained('openai/clip-vit-large-patch14')

     lowerCAmelCase: List[str]							=						UnCLIPImageVariationPipeline(
         decoder=txtaimg.decoder,
         text_encoder=txtaimg.text_encoder,
         tokenizer=txtaimg.tokenizer,
         text_proj=txtaimg.text_proj,
         feature_extractor=feature_extractor,
         image_encoder=image_encoder,
         super_res_first=txtaimg.super_res_first,
         super_res_last=txtaimg.super_res_last,
         decoder_scheduler=txtaimg.decoder_scheduler,
         super_res_scheduler=txtaimg.super_res_scheduler,
     )

     imgaimg.save_pretrained(args.dump_path)