code: import argparse
  
  from transformers import ConvBertConfig, ConvBertModel, TFConvBertModel, load_tf_weights_in_convbert
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  
  
  
  def 							_lowerCamelCase(				__snake_case						,						__snake_case						,						__snake_case	)  ->   Union[str, Any]:
  		__snake_case		       =     ConvBertConfig.from_json_file(__snake_case	)
  		__snake_case		       =     ConvBertModel(__snake_case	)
  
  		__snake_case		       =     load_tf_weights_in_convbert(__snake_case						,						__snake_case						,						__snake_case	)
  		model.save_pretrained(__snake_case	)
  
  		__snake_case		       =     TFConvBertModel.from_pretrained(__snake_case						,						from_pt=__snake_case	)
  		tf_model.save_pretrained(__snake_case	)
  
  
  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(
  		    '''--convbert_config_file''',
  		    default=None,
  		    type=str,
  		    required=True,
  		    help=(
  		        '''The config json file corresponding to the pre-trained ConvBERT model. \n'''
  		        '''This specifies the model architecture.'''
  		    ),
  		)
  		parser.add_argument(
  		    '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
  		)
  		lowerCamelCase__           =				parser.parse_args()
  		convert_orig_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.convbert_config_file, args.pytorch_dump_path)
  
  
  
  
  
  
style_context: import shutil
  import tempfile
  import unittest
  
  import numpy as np
  import pytest
  
  from transformers.testing_utils import require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  
  if is_torch_available():
  		from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
  else:
  		lowerCamelCase__           =				False
  
  if is_vision_available():
  		from PIL import Image
  
  		from transformers import (
  		    AutoProcessor,
  		    PixaStructImageProcessor,
  		    PixaStructProcessor,
  		    PreTrainedTokenizerFast,
  		    TaTokenizer,
  		)
  
  
  
  
  @unittest.skipIf(
      not is_torch_greater_or_equal_than_1_11			,      reason="""`Pix2StructImageProcessor` requires `torch>=1.11.0`."""			,      )
  @require_vision
  @require_torch
  class 					UpperCamelCase	(     unittest.TestCase      ):
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[int]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     tempfile.mkdtemp()
  
  							__snake_case		       =     PixaStructImageProcessor()
  							__snake_case		       =     TaTokenizer.from_pretrained("t5-small"						)
  
  							__snake_case		       =     PixaStructProcessor(_lowerCAmelCase      ,_lowerCAmelCase						)
  
  							processor.save_pretrained(self.tmpdirname						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Dict      ,**_lowerCAmelCase :					List[str]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return AutoProcessor.from_pretrained(self.tmpdirname      ,**_lowerCAmelCase						).tokenizer
  
  
  
  
  					def 							UpperCamelCase_						( self :					Any      ,**_lowerCAmelCase :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return AutoProcessor.from_pretrained(self.tmpdirname      ,**_lowerCAmelCase						).image_processor
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[int]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							shutil.rmtree(self.tmpdirname						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     [np.random.randint(255      ,size=(3, 30, 400)      ,dtype=np.uinta						)]
  
  							__snake_case		       =     [Image.fromarray(np.moveaxis(_lowerCAmelCase      ,0      ,-1						)						) for x in image_inputs]
  
  							return image_inputs
  
  
  
  
  					def 							UpperCamelCase_						( self :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     PixaStructProcessor(tokenizer=self.get_tokenizer()      ,image_processor=self.get_image_processor()						)
  							processor.save_pretrained(self.tmpdirname						)
  
  							__snake_case		       =     self.get_tokenizer(bos_token="(BOS)"      ,eos_token="(EOS)"						)
  							__snake_case		       =     self.get_image_processor(do_normalize=_lowerCAmelCase      ,padding_value=1.0						)
  
  							__snake_case		       =     PixaStructProcessor.from_pretrained(
  							    self.tmpdirname      ,bos_token="(BOS)"      ,eos_token="(EOS)"      ,do_normalize=_lowerCAmelCase      ,padding_value=1.0						)
  
  							self.assertEqual(processor.tokenizer.get_vocab()      ,tokenizer_add_kwargs.get_vocab()						)
  							self.assertIsInstance(processor.tokenizer      ,_lowerCAmelCase						)
  
  							self.assertEqual(processor.image_processor.to_json_string()      ,image_processor_add_kwargs.to_json_string()						)
  							self.assertIsInstance(processor.image_processor      ,_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[int]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.get_image_processor()
  							__snake_case		       =     self.get_tokenizer()
  
  							__snake_case		       =     PixaStructProcessor(tokenizer=_lowerCAmelCase      ,image_processor=_lowerCAmelCase						)
  
  							__snake_case		       =     self.prepare_image_inputs()
  
  							__snake_case		       =     image_processor(_lowerCAmelCase      ,return_tensors="np"						)
  							__snake_case		       =     processor(images=_lowerCAmelCase      ,return_tensors="np"						)
  
  							for key in input_feat_extract.keys():
  									self.assertAlmostEqual(input_feat_extract[key].sum()      ,input_processor[key].sum()      ,delta=1E-2						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[str]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.get_image_processor()
  							__snake_case		       =     self.get_tokenizer()
  
  							__snake_case		       =     PixaStructProcessor(tokenizer=_lowerCAmelCase      ,image_processor=_lowerCAmelCase						)
  
  							__snake_case		       =     "lower newer"
  
  							__snake_case		       =     processor(text=_lowerCAmelCase						)
  
  							__snake_case		       =     tokenizer(_lowerCAmelCase      ,return_token_type_ids=_lowerCAmelCase      ,add_special_tokens=_lowerCAmelCase						)
  
  							for key in encoded_tok.keys():
  									self.assertListEqual(encoded_tok[key]      ,encoded_processor[key]						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.get_image_processor()
  							__snake_case		       =     self.get_tokenizer()
  
  							__snake_case		       =     PixaStructProcessor(tokenizer=_lowerCAmelCase      ,image_processor=_lowerCAmelCase						)
  
  							__snake_case		       =     "lower newer"
  							__snake_case		       =     self.prepare_image_inputs()
  
  							__snake_case		       =     processor(text=_lowerCAmelCase      ,images=_lowerCAmelCase						)
  
  							self.assertListEqual(
  							    list(inputs.keys()						)      ,["flattened_patches", "attention_mask", "decoder_attention_mask", "decoder_input_ids"]						)
  
  							# test if it raises when no input is passed
  							with pytest.raises(_lowerCAmelCase						):
  									processor()
  
  
  
  
  					def 							UpperCamelCase_						( self :					str						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.get_image_processor()
  							__snake_case		       =     self.get_tokenizer()
  
  							__snake_case		       =     PixaStructProcessor(tokenizer=_lowerCAmelCase      ,image_processor=_lowerCAmelCase						)
  
  							__snake_case		       =     "lower newer"
  							__snake_case		       =     self.prepare_image_inputs()
  
  							__snake_case		       =     processor(text=_lowerCAmelCase      ,images=_lowerCAmelCase						)
  
  							__snake_case		       =     [512, 1_024, 2_048, 4_096]
  							__snake_case		       =     [770, 770, 770, 770]
  							# with text
  							for i, max_patch in enumerate(_lowerCAmelCase						):
  									__snake_case		       =     processor(text=_lowerCAmelCase      ,images=_lowerCAmelCase      ,max_patches=_lowerCAmelCase						)
  									self.assertEqual(inputs["flattened_patches"][0].shape[0]      ,_lowerCAmelCase						)
  									self.assertEqual(inputs["flattened_patches"][0].shape[1]      ,expected_hidden_size[i]						)
  
  							# without text input
  							for i, max_patch in enumerate(_lowerCAmelCase						):
  									__snake_case		       =     processor(images=_lowerCAmelCase      ,max_patches=_lowerCAmelCase						)
  									self.assertEqual(inputs["flattened_patches"][0].shape[0]      ,_lowerCAmelCase						)
  									self.assertEqual(inputs["flattened_patches"][0].shape[1]      ,expected_hidden_size[i]						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Union[str, Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.get_image_processor()
  							__snake_case		       =     self.get_tokenizer()
  
  							__snake_case		       =     PixaStructProcessor(tokenizer=_lowerCAmelCase      ,image_processor=_lowerCAmelCase						)
  
  							__snake_case		       =     [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
  							__snake_case		       =     processor.batch_decode(_lowerCAmelCase						)
  							__snake_case		       =     tokenizer.batch_decode(_lowerCAmelCase						)
  
  							self.assertListEqual(_lowerCAmelCase      ,_lowerCAmelCase						)
  
  
  
  
  
  
  
  					def 							UpperCamelCase_						( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.get_image_processor()
  							__snake_case		       =     self.get_tokenizer()
  
  							__snake_case		       =     PixaStructProcessor(tokenizer=_lowerCAmelCase      ,image_processor=_lowerCAmelCase						)
  
  							__snake_case		       =     "lower newer"
  							__snake_case		       =     self.prepare_image_inputs()
  
  							__snake_case		       =     processor(text=_lowerCAmelCase      ,images=_lowerCAmelCase						)
  
  							# For now the processor supports only ["flattened_patches", "input_ids", "attention_mask", "decoder_attention_mask"]
  							self.assertListEqual(
  							    list(inputs.keys()						)      ,["flattened_patches", "attention_mask", "decoder_attention_mask", "decoder_input_ids"]						)
  
  							__snake_case		       =     processor(text=_lowerCAmelCase						)
  
  							# For now the processor supports only ["flattened_patches", "input_ids", "attention_mask", "decoder_attention_mask"]
  							self.assertListEqual(list(inputs.keys()						)      ,["input_ids", "attention_mask"]						)
  
  
  
  
  
  