code: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import argparse
  
  import torch
  from torch import nn
  
  from transformers import PLBartConfig, PLBartForConditionalGeneration, PLBartForSequenceClassification
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = [
  		    "encoder.version",
  		    "decoder.version",
  		    "model.encoder.version",
  		    "model.decoder.version",
  		    "_float_tensor",
  		    "decoder.output_projection.weight",
  		]
  		for k in ignore_keys:
  				state_dict.pop(lowercase_		,							lowercase_						)
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case ,					_snake_case			 = emb.weight.shape
  		_snake_case			 = nn.Linear(lowercase_		,							lowercase_		,							bias=lowercase_						)
  		_snake_case			 = emb.weight.data
  		return lin_layer
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_="uclanlp/plbart-base"		,							lowercase_=False		,							lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = torch.load(lowercase_		,							map_location="cpu"						)["model"]
  		remove_ignore_keys_(lowercase_						)
  		_snake_case			 = state_dict["encoder.embed_tokens.weight"].shape[0]
  
  		_snake_case			 = PLBartConfig.from_pretrained(lowercase_		,							vocab_size=lowercase_						)
  
  		_snake_case			 = state_dict["decoder.embed_tokens.weight"]
  		if not classification:
  				_snake_case			 = PLBartForConditionalGeneration(lowercase_						)
  				model.model.load_state_dict(lowercase_						)
  				if finetuned:
  						_snake_case			 = make_linear_from_emb(model.model.shared						)
  
  		else:
  				_snake_case			 = {}
  				for key, value in state_dict.copy().items():
  						if key.startswith("classification_heads.sentence_classification_head"						):
  								_snake_case			 = value
  								state_dict.pop(lowercase_						)
  				_snake_case			 = PLBartForSequenceClassification(lowercase_						)
  				model.model.load_state_dict(lowercase_						)
  				model.classification_head.load_state_dict(lowercase_						)
  
  		return model
  
  
  if __name__ == "__main__":
  						_lowerCamelCase							:		Dict  			=						argparse.ArgumentParser()
  						# Required parameters
  						parser.add_argument('fairseq_path', type=str, help='model.pt on local filesystem.')
  						parser.add_argument('pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
  						parser.add_argument(
  						    '--hf_config',
  						    default='uclanlp/plbart-base',
  						    type=str,
  						    help='Which huggingface architecture to use: plbart-base',
  						)
  						parser.add_argument('--finetuned', action='store_true', help='whether the model is a fine-tuned checkpoint')
  						parser.add_argument(
  						    '--classification', action='store_true', help='whether the model is a classification checkpoint'
  						)
  						_lowerCamelCase							:		Any  			=						parser.parse_args()
  						_lowerCamelCase							:		str  			=						convert_fairseq_plbart_checkpoint_from_disk(
  						    args.fairseq_path,
  						    hf_config_path=args.hf_config,
  						    finetuned=args.finetuned,
  						    classification=args.classification,
  						)
  						model.save_pretrained(args.pytorch_dump_folder_path)
  
  
  
  
  
  
style_context: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import unittest
  import warnings
  from dataclasses import dataclass
  
  from transformers.convert_slow_tokenizer import SpmConverter
  from transformers.testing_utils import get_tests_dir
  
  
  
  
  
  @dataclass
  class   lowerCamelCase_							:
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  					lowercase__					=				42
  
  
  
  
  
  class   lowerCamelCase_							( unittest.TestCase							):
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							_snake_case			 = get_tests_dir("fixtures/test_sentencepiece.model"				)
  							_snake_case			 = get_tests_dir("fixtures/test_sentencepiece_with_bytefallback.model"				)
  
  							_snake_case			 = FakeOriginalTokenizer(vocab_file=__UpperCamelCase				)
  
  							with warnings.catch_warnings(record=__UpperCamelCase				) as w:
  									_snake_case			 = SpmConverter(__UpperCamelCase				)
  							self.assertEqual(len(__UpperCamelCase				),						0				)
  
  							_snake_case			 = FakeOriginalTokenizer(vocab_file=__UpperCamelCase				)
  
  							with warnings.catch_warnings(record=__UpperCamelCase				) as w:
  									_snake_case			 = SpmConverter(__UpperCamelCase				)
  							self.assertEqual(len(__UpperCamelCase				),						1				)
  
  							self.assertIn(
  							    "The sentencepiece tokenizer that you are converting to a fast tokenizer uses the byte fallback option"
  							    " which is not implemented in the fast tokenizers.",						str(w[0].message				),						)
  
  
  
  
  
  