


'''simple docstring'''




import argparse
from collections import OrderedDict
from pathlib import Path

import requests
import torch
from PIL import Image

from transformers import GLPNConfig, GLPNForDepthEstimation, GLPNImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
__snake_case    						=logging.get_logger(__name__)





def 	a_					( lowerCamelCase	:     Any				):
   lowerCAmelCase     =			OrderedDict()
   for key, value in state_dict.items():
      if key.startswith('module.encoder'				):
         lowerCAmelCase     =			key.replace('module.encoder'	, 'glpn.encoder'				)
      if key.startswith('module.decoder'				):
         lowerCAmelCase     =			key.replace('module.decoder'	, 'decoder.stages'				)
      if "patch_embed" in key:
         # replace for example patch_embed1 by patch_embeddings.0
         lowerCAmelCase     =			key[key.find('patch_embed'				) + len('patch_embed'				)]
         lowerCAmelCase     =			key.replace(f'''patch_embed{idx}'''	, f'''patch_embeddings.{int(lowerCamelCase				)-1}'''				)
      if "norm" in key:
         lowerCAmelCase     =			key.replace('norm'	, 'layer_norm'				)
      if "glpn.encoder.layer_norm" in key:
         # replace for example layer_norm1 by layer_norm.0
         lowerCAmelCase     =			key[key.find('glpn.encoder.layer_norm'				) + len('glpn.encoder.layer_norm'				)]
         lowerCAmelCase     =			key.replace(f'''layer_norm{idx}'''	, f'''layer_norm.{int(lowerCamelCase				)-1}'''				)
      if "layer_norm1" in key:
         lowerCAmelCase     =			key.replace('layer_norm1'	, 'layer_norm_1'				)
      if "layer_norm2" in key:
         lowerCAmelCase     =			key.replace('layer_norm2'	, 'layer_norm_2'				)
      if "block" in key:
         # replace for example block1 by block.0
         lowerCAmelCase     =			key[key.find('block'				) + len('block'				)]
         lowerCAmelCase     =			key.replace(f'''block{idx}'''	, f'''block.{int(lowerCamelCase				)-1}'''				)
      if "attn.q" in key:
         lowerCAmelCase     =			key.replace('attn.q'	, 'attention.self.query'				)
      if "attn.proj" in key:
         lowerCAmelCase     =			key.replace('attn.proj'	, 'attention.output.dense'				)
      if "attn" in key:
         lowerCAmelCase     =			key.replace('attn'	, 'attention.self'				)
      if "fc1" in key:
         lowerCAmelCase     =			key.replace('fc1'	, 'dense1'				)
      if "fc2" in key:
         lowerCAmelCase     =			key.replace('fc2'	, 'dense2'				)
      if "linear_pred" in key:
         lowerCAmelCase     =			key.replace('linear_pred'	, 'classifier'				)
      if "linear_fuse" in key:
         lowerCAmelCase     =			key.replace('linear_fuse.conv'	, 'linear_fuse'				)
         lowerCAmelCase     =			key.replace('linear_fuse.bn'	, 'batch_norm'				)
      if "linear_c" in key:
         # replace for example linear_c4 by linear_c.3
         lowerCAmelCase     =			key[key.find('linear_c'				) + len('linear_c'				)]
         lowerCAmelCase     =			key.replace(f'''linear_c{idx}'''	, f'''linear_c.{int(lowerCamelCase				)-1}'''				)
      if "bot_conv" in key:
         lowerCAmelCase     =			key.replace('bot_conv'	, '0.convolution'				)
      if "skip_conv1" in key:
         lowerCAmelCase     =			key.replace('skip_conv1'	, '1.convolution'				)
      if "skip_conv2" in key:
         lowerCAmelCase     =			key.replace('skip_conv2'	, '2.convolution'				)
      if "fusion1" in key:
         lowerCAmelCase     =			key.replace('fusion1'	, '1.fusion'				)
      if "fusion2" in key:
         lowerCAmelCase     =			key.replace('fusion2'	, '2.fusion'				)
      if "fusion3" in key:
         lowerCAmelCase     =			key.replace('fusion3'	, '3.fusion'				)
      if "fusion" in key and "conv" in key:
         lowerCAmelCase     =			key.replace('conv'	, 'convolutional_layer'				)
      if key.startswith('module.last_layer_depth'				):
         lowerCAmelCase     =			key.replace('module.last_layer_depth'	, 'head.head'				)
      lowerCAmelCase     =			value

   return new_state_dict





def 	a_					( lowerCamelCase	:     List[str]	, lowerCamelCase	:     str				):
   # for each of the encoder blocks:
   for i in range(config.num_encoder_blocks				):
      for j in range(config.depths[i]				):
         # read in weights + bias of keys and values (which is a single matrix in the original implementation)
         lowerCAmelCase     =			state_dict.pop(f'''glpn.encoder.block.{i}.{j}.attention.self.kv.weight'''				)
         lowerCAmelCase     =			state_dict.pop(f'''glpn.encoder.block.{i}.{j}.attention.self.kv.bias'''				)
         # next, add keys and values (in that order) to the state dict
         lowerCAmelCase     =			kv_weight[
             : config.hidden_sizes[i], :
         ]
         lowerCAmelCase     =			kv_bias[: config.hidden_sizes[i]]
         lowerCAmelCase     =			kv_weight[
             config.hidden_sizes[i] :, :
         ]
         lowerCAmelCase     =			kv_bias[config.hidden_sizes[i] :]





def 	a_					( ):
   lowerCAmelCase     =			'http://images.cocodataset.org/val2017/000000039769.jpg'
   lowerCAmelCase     =			Image.open(requests.get(lowerCamelCase	, stream=lowerCamelCase				).raw				)

   return image





@torch.no_grad()
def 	a_					( lowerCamelCase	:     List[Any]	, lowerCamelCase	:     Tuple	, lowerCamelCase	:     Optional[Any]=False	, lowerCamelCase	:     List[str]=None				):
   lowerCAmelCase     =			GLPNConfig(hidden_sizes=[64, 128, 320, 512]	, decoder_hidden_size=64	, depths=[3, 8, 27, 3]				)

   # load image processor (only resize + rescale)
   lowerCAmelCase     =			GLPNImageProcessor()

   # prepare image
   lowerCAmelCase     =			prepare_img()
   lowerCAmelCase     =			image_processor(images=lowerCamelCase	, return_tensors='pt'				).pixel_values

   logger.info('Converting model...'				)

   # load original state dict
   lowerCAmelCase     =			torch.load(lowerCamelCase	, map_location=torch.device('cpu'				)				)

   # rename keys
   lowerCAmelCase     =			rename_keys(lowerCamelCase				)

   # key and value matrices need special treatment
   read_in_k_v(lowerCamelCase	, lowerCamelCase				)

   # create HuggingFace model and load state dict
   lowerCAmelCase     =			GLPNForDepthEstimation(lowerCamelCase				)
   model.load_state_dict(lowerCamelCase				)
   model.eval()

   # forward pass
   lowerCAmelCase     =			model(lowerCamelCase				)
   lowerCAmelCase     =			outputs.predicted_depth

   # verify output
   if model_name is not None:
      if "nyu" in model_name:
         lowerCAmelCase     =			torch.tensor(
             [[4.4_147, 4.0_873, 4.0_673], [3.7_890, 3.2_881, 3.1_525], [3.7_674, 3.5_423, 3.4_913]]				)
      elif "kitti" in model_name:
         lowerCAmelCase     =			torch.tensor(
             [[3.4_291, 2.7_865, 2.5_151], [3.2_841, 2.7_021, 2.3_502], [3.1_147, 2.4_625, 2.2_481]]				)
      else:
         raise ValueError(f'''Unknown model name: {model_name}'''				)

      lowerCAmelCase     =			torch.Size([1, 480, 640]				)

      assert predicted_depth.shape == expected_shape
      assert torch.allclose(predicted_depth[0, :3, :3]	, lowerCamelCase	, atol=1e-4				)
      print('Looks ok!'				)

   # finally, push to hub if required
   if push_to_hub:
      logger.info('Pushing model and image processor to the hub...'				)
      model.push_to_hub(
          repo_path_or_name=Path(lowerCamelCase	, lowerCamelCase				)	, organization='nielsr'	, commit_message='Add model'	, use_temp_dir=lowerCamelCase	, )
      image_processor.push_to_hub(
          repo_path_or_name=Path(lowerCamelCase	, lowerCamelCase				)	, organization='nielsr'	, commit_message='Add image processor'	, use_temp_dir=lowerCamelCase	, )


if __name__ == "__main__":
       __snake_case    						=argparse.ArgumentParser()

       parser.add_argument(
           """--checkpoint_path""",
           default=None,
           type=str,
           help="""Path to the original PyTorch checkpoint (.pth file).""",
       )
       parser.add_argument(
           """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the folder to output PyTorch model."""
       )
       parser.add_argument(
           """--push_to_hub""", action="""store_true""", help="""Whether to upload the model to the HuggingFace hub."""
       )
       parser.add_argument(
           """--model_name""",
           default="""glpn-kitti""",
           type=str,
           help="""Name of the model in case you're pushing to the hub.""",
       )
       __snake_case    						=parser.parse_args()
       convert_glpn_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name)










'''simple docstring'''


import argparse
from collections import OrderedDict
from pathlib import Path

import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision.transforms import functional as F

from transformers import DetrImageProcessor, TableTransformerConfig, TableTransformerForObjectDetection
from transformers.utils import logging


logging.set_verbosity_info()
_lowerCamelCase	:       int      	=	logging.get_logger(__name__)

# here we list all keys to be renamed (original name on the left, our name on the right)
_lowerCamelCase	:       int      	=	[]
for i in range(6):
   # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
   rename_keys.append(
       (f'''transformer.encoder.layers.{i}.self_attn.out_proj.weight''', f'''encoder.layers.{i}.self_attn.out_proj.weight''')
   )
   rename_keys.append(
       (f'''transformer.encoder.layers.{i}.self_attn.out_proj.bias''', f'''encoder.layers.{i}.self_attn.out_proj.bias''')
   )
   rename_keys.append((f'''transformer.encoder.layers.{i}.linear1.weight''', f'''encoder.layers.{i}.fc1.weight'''))
   rename_keys.append((f'''transformer.encoder.layers.{i}.linear1.bias''', f'''encoder.layers.{i}.fc1.bias'''))
   rename_keys.append((f'''transformer.encoder.layers.{i}.linear2.weight''', f'''encoder.layers.{i}.fc2.weight'''))
   rename_keys.append((f'''transformer.encoder.layers.{i}.linear2.bias''', f'''encoder.layers.{i}.fc2.bias'''))
   rename_keys.append(
       (f'''transformer.encoder.layers.{i}.norm1.weight''', f'''encoder.layers.{i}.self_attn_layer_norm.weight''')
   )
   rename_keys.append((f'''transformer.encoder.layers.{i}.norm1.bias''', f'''encoder.layers.{i}.self_attn_layer_norm.bias'''))
   rename_keys.append((f'''transformer.encoder.layers.{i}.norm2.weight''', f'''encoder.layers.{i}.final_layer_norm.weight'''))
   rename_keys.append((f'''transformer.encoder.layers.{i}.norm2.bias''', f'''encoder.layers.{i}.final_layer_norm.bias'''))
   # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
   rename_keys.append(
       (f'''transformer.decoder.layers.{i}.self_attn.out_proj.weight''', f'''decoder.layers.{i}.self_attn.out_proj.weight''')
   )
   rename_keys.append(
       (f'''transformer.decoder.layers.{i}.self_attn.out_proj.bias''', f'''decoder.layers.{i}.self_attn.out_proj.bias''')
   )
   rename_keys.append(
       (
           f'''transformer.decoder.layers.{i}.multihead_attn.out_proj.weight''',
           f'''decoder.layers.{i}.encoder_attn.out_proj.weight''',
       )
   )
   rename_keys.append(
       (
           f'''transformer.decoder.layers.{i}.multihead_attn.out_proj.bias''',
           f'''decoder.layers.{i}.encoder_attn.out_proj.bias''',
       )
   )
   rename_keys.append((f'''transformer.decoder.layers.{i}.linear1.weight''', f'''decoder.layers.{i}.fc1.weight'''))
   rename_keys.append((f'''transformer.decoder.layers.{i}.linear1.bias''', f'''decoder.layers.{i}.fc1.bias'''))
   rename_keys.append((f'''transformer.decoder.layers.{i}.linear2.weight''', f'''decoder.layers.{i}.fc2.weight'''))
   rename_keys.append((f'''transformer.decoder.layers.{i}.linear2.bias''', f'''decoder.layers.{i}.fc2.bias'''))
   rename_keys.append(
       (f'''transformer.decoder.layers.{i}.norm1.weight''', f'''decoder.layers.{i}.self_attn_layer_norm.weight''')
   )
   rename_keys.append((f'''transformer.decoder.layers.{i}.norm1.bias''', f'''decoder.layers.{i}.self_attn_layer_norm.bias'''))
   rename_keys.append(
       (f'''transformer.decoder.layers.{i}.norm2.weight''', f'''decoder.layers.{i}.encoder_attn_layer_norm.weight''')
   )
   rename_keys.append(
       (f'''transformer.decoder.layers.{i}.norm2.bias''', f'''decoder.layers.{i}.encoder_attn_layer_norm.bias''')
   )
   rename_keys.append((f'''transformer.decoder.layers.{i}.norm3.weight''', f'''decoder.layers.{i}.final_layer_norm.weight'''))
   rename_keys.append((f'''transformer.decoder.layers.{i}.norm3.bias''', f'''decoder.layers.{i}.final_layer_norm.bias'''))

# convolutional projection + query embeddings + layernorm of encoder + layernorm of decoder + class and bounding box heads
rename_keys.extend(
    [
        ("input_proj.weight", "input_projection.weight"),
        ("input_proj.bias", "input_projection.bias"),
        ("query_embed.weight", "query_position_embeddings.weight"),
        ("transformer.encoder.norm.weight", "encoder.layernorm.weight"),
        ("transformer.encoder.norm.bias", "encoder.layernorm.bias"),
        ("transformer.decoder.norm.weight", "decoder.layernorm.weight"),
        ("transformer.decoder.norm.bias", "decoder.layernorm.bias"),
        ("class_embed.weight", "class_labels_classifier.weight"),
        ("class_embed.bias", "class_labels_classifier.bias"),
        ("bbox_embed.layers.0.weight", "bbox_predictor.layers.0.weight"),
        ("bbox_embed.layers.0.bias", "bbox_predictor.layers.0.bias"),
        ("bbox_embed.layers.1.weight", "bbox_predictor.layers.1.weight"),
        ("bbox_embed.layers.1.bias", "bbox_predictor.layers.1.bias"),
        ("bbox_embed.layers.2.weight", "bbox_predictor.layers.2.weight"),
        ("bbox_embed.layers.2.bias", "bbox_predictor.layers.2.bias"),
    ]
)







def 				__lowerCamelCase				(   A__    ,						A__    ,						A__    )       ->	Dict:






   """simple docstring"""
   UpperCamelCase					=  state_dict.pop(A__    )
   UpperCamelCase					=  val







def 				__lowerCamelCase				(   A__    )       ->	int:






   """simple docstring"""
   UpperCamelCase					=  OrderedDict()
   for key, value in state_dict.items():
      if "backbone.0.body" in key:
         UpperCamelCase					=  key.replace('backbone.0.body'    ,						'backbone.conv_encoder.model'    )
         UpperCamelCase					=  value
      else:
         UpperCamelCase					=  value

   return new_state_dict







def 				__lowerCamelCase				(   A__    )       ->	Dict:






   """simple docstring"""
   UpperCamelCase					=  ''

   # first: transformer encoder
   for i in range(6    ):
      # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
      UpperCamelCase					=  state_dict.pop(F"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight"""    )
      UpperCamelCase					=  state_dict.pop(F"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias"""    )
      # next, add query, keys and values (in that order) to the state dict
      UpperCamelCase					=  in_proj_weight[:256, :]
      UpperCamelCase					=  in_proj_bias[:256]
      UpperCamelCase					=  in_proj_weight[256:512, :]
      UpperCamelCase					=  in_proj_bias[256:512]
      UpperCamelCase					=  in_proj_weight[-256:, :]
      UpperCamelCase					=  in_proj_bias[-256:]
   # next: transformer decoder (which is a bit more complex because it also includes cross-attention)
   for i in range(6    ):
      # read in weights + bias of input projection layer of self-attention
      UpperCamelCase					=  state_dict.pop(F"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight"""    )
      UpperCamelCase					=  state_dict.pop(F"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias"""    )
      # next, add query, keys and values (in that order) to the state dict
      UpperCamelCase					=  in_proj_weight[:256, :]
      UpperCamelCase					=  in_proj_bias[:256]
      UpperCamelCase					=  in_proj_weight[256:512, :]
      UpperCamelCase					=  in_proj_bias[256:512]
      UpperCamelCase					=  in_proj_weight[-256:, :]
      UpperCamelCase					=  in_proj_bias[-256:]
      # read in weights + bias of input projection layer of cross-attention
      UpperCamelCase					=  state_dict.pop(
          F"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight"""    )
      UpperCamelCase					=  state_dict.pop(F"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias"""    )
      # next, add query, keys and values (in that order) of cross-attention to the state dict
      UpperCamelCase					=  in_proj_weight_cross_attn[:256, :]
      UpperCamelCase					=  in_proj_bias_cross_attn[:256]
      UpperCamelCase					=  in_proj_weight_cross_attn[256:512, :]
      UpperCamelCase					=  in_proj_bias_cross_attn[256:512]
      UpperCamelCase					=  in_proj_weight_cross_attn[-256:, :]
      UpperCamelCase					=  in_proj_bias_cross_attn[-256:]







def 				__lowerCamelCase				(   A__    ,						A__    )       ->	Optional[int]:






   """simple docstring"""
   UpperCamelCase				,      UpperCamelCase					=  image.size
   UpperCamelCase					=  max(A__    ,						A__    )
   UpperCamelCase					=  800 if 'detection' in checkpoint_url else 1_000
   UpperCamelCase					=  target_max_size / current_max_size
   UpperCamelCase					=  image.resize((int(round(scale * width    )    ), int(round(scale * height    )    ))    )

   return resized_image







def 				__lowerCamelCase				(   A__    )       ->	List[Any]:






   """simple docstring"""
   UpperCamelCase					=  F.to_tensor(A__    )
   UpperCamelCase					=  F.normalize(A__    ,						mean=[0.485, 0.456, 0.406]    ,						std=[0.229, 0.224, 0.225]    )
   return image







@torch.no_grad()
def 				__lowerCamelCase				(   A__    ,						A__    ,						A__    )       ->	Optional[Any]:






   """simple docstring"""
   logger.info('Converting model...'    )

   # load original state dict
   UpperCamelCase					=  torch.hub.load_state_dict_from_url(A__    ,						map_location='cpu'    )
   # rename keys
   for src, dest in rename_keys:
      rename_key(A__    ,						A__    ,						A__    )
   UpperCamelCase					=  rename_backbone_keys(A__    )
   # query, key and value matrices need special treatment
   read_in_q_k_v(A__    )
   # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
   UpperCamelCase					=  'model.'
   for key in state_dict.copy().keys():
      if not key.startswith('class_labels_classifier'    ) and not key.startswith('bbox_predictor'    ):
         UpperCamelCase					=  state_dict.pop(A__    )
         UpperCamelCase					=  val
    # create HuggingFace model and load state dict
   UpperCamelCase					=  TableTransformerConfig(
       backbone='resnet18'    ,						mask_loss_coefficient=1    ,						dice_loss_coefficient=1    ,						ce_loss_coefficient=1    ,						bbox_loss_coefficient=5    ,						giou_loss_coefficient=2    ,						eos_coefficient=0.4    ,						class_cost=1    ,						bbox_cost=5    ,						giou_cost=2    ,						)

   if "detection" in checkpoint_url:
      UpperCamelCase					=  15
      UpperCamelCase					=  2
      UpperCamelCase					=  {0: 'table', 1: 'table rotated'}
      UpperCamelCase					=  idalabel
      UpperCamelCase					=  {v: k for k, v in idalabel.items()}
   else:
      UpperCamelCase					=  125
      UpperCamelCase					=  6
      UpperCamelCase					=  {
          0: 'table',
          1: 'table column',
          2: 'table row',
          3: 'table column header',
          4: 'table projected row header',
          5: 'table spanning cell',
      }
      UpperCamelCase					=  idalabel
      UpperCamelCase					=  {v: k for k, v in idalabel.items()}

   UpperCamelCase					=  DetrImageProcessor(
       format='coco_detection'    ,						max_size=800 if 'detection' in checkpoint_url else 1_000    )
   UpperCamelCase					=  TableTransformerForObjectDetection(A__    )
   model.load_state_dict(A__    )
   model.eval()

   # verify our conversion
   UpperCamelCase					=  'example_pdf.png' if 'detection' in checkpoint_url else 'example_table.png'
   UpperCamelCase					=  hf_hub_download(repo_id='nielsr/example-pdf'    ,						repo_type='dataset'    ,						filename=A__    )
   UpperCamelCase					=  Image.open(A__    ).convert('RGB'    )
   UpperCamelCase					=  normalize(resize(A__    ,						A__    )    ).unsqueeze(0    )

   UpperCamelCase					=  model(A__    )

   if "detection" in checkpoint_url:
      UpperCamelCase					=  (1, 15, 3)
      UpperCamelCase					=  torch.tensor(
          [[-6.7_897, -16.9_985, 6.7_937], [-8.0_186, -22.2_192, 6.9_677], [-7.3_117, -21.0_708, 7.4_055]]    )
      UpperCamelCase					=  torch.tensor([[0.4_867, 0.1_767, 0.6_732], [0.6_718, 0.4_479, 0.3_830], [0.4_716, 0.1_760, 0.6_364]]    )

   else:
      UpperCamelCase					=  (1, 125, 7)
      UpperCamelCase					=  torch.tensor(
          [[-18.1_430, -8.3_214, 4.8_274], [-18.4_685, -7.1_361, -4.2_667], [-26.3_693, -9.3_429, -4.9_962]]    )
      UpperCamelCase					=  torch.tensor([[0.4_983, 0.5_595, 0.9_440], [0.4_916, 0.6_315, 0.5_954], [0.6_108, 0.8_637, 0.1_135]]    )

   assert outputs.logits.shape == expected_shape
   assert torch.allclose(outputs.logits[0, :3, :3]    ,						A__    ,						atol=1e-4    )
   assert torch.allclose(outputs.pred_boxes[0, :3, :3]    ,						A__    ,						atol=1e-4    )
   print('Looks ok!'    )

   if pytorch_dump_folder_path is not None:
      # Save model and image processor
      logger.info(F"""Saving PyTorch model and image processor to {pytorch_dump_folder_path}..."""    )
      Path(A__    ).mkdir(exist_ok=A__    )
      model.save_pretrained(A__    )
      image_processor.save_pretrained(A__    )

   if push_to_hub:
      # Push model to HF hub
      logger.info('Pushing model to the hub...'    )
      UpperCamelCase					=  (
          'microsoft/table-transformer-detection'
          if 'detection' in checkpoint_url
          else 'microsoft/table-transformer-structure-recognition'
      )
      model.push_to_hub(A__    )
      image_processor.push_to_hub(A__    )


if __name__ == "__main__":
   _lowerCamelCase	:       List[str]      	=	argparse.ArgumentParser()

   parser.add_argument(
       "--checkpoint_url",
       default="https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth",
       type=str,
       choices=[
           "https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth",
           "https://pubtables1m.blob.core.windows.net/model/pubtables1m_structure_detr_r18.pth",
       ],
       help="URL of the Table Transformer checkpoint you'd like to convert.",
   )
   parser.add_argument(
       "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
   )
   parser.add_argument(
       "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
   )
   _lowerCamelCase	:       int      	=	parser.parse_args()
   convert_table_transformer_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)

