


import re
import time
from typing import Optional

import IPython.display as disp

from ..trainer_callback import TrainerCallback
from ..trainer_utils import IntervalStrategy, has_length





def 	_lowerCAmelCase					( UpperCamelCase__:  int    )			-> Union[str, Any]:





	"""simple docstring"""







	A             =					int(UpperCamelCase__    )
	A       ,      A       ,      A             =					t // 36_00, (t // 60) % 60, t % 60
	return f'{h}:{m:02d}:{s:02d}' if h != 0 else f'{m:02d}:{s:02d}'





def 	_lowerCAmelCase					( UpperCamelCase__:  str				,       UpperCamelCase__:  Optional[Any]				,       UpperCamelCase__:  List[Any]				,       UpperCamelCase__:  Any				,       UpperCamelCase__:  Tuple=3_00    )			-> List[str]:





	"""simple docstring"""







	return f'\n    <div>\n      {prefix}\n      <progress value=\'{value}\' max=\'{total}\' style=\'width:{width}px; height:20px; vertical-align: middle;\'></progress>\n      {label}\n    </div>\n    '





def 	_lowerCAmelCase					( UpperCamelCase__:  Optional[int]    )			-> List[str]:





	"""simple docstring"""







	A             =					"""<table border=\"1\" class=\"dataframe\">\n"""
	html_code += """  <thead>\n <tr style="text-align: left;">\n"""
	for i in items[0]:
		html_code += f'      <th>{i}</th>\n'
	html_code += "    </tr>\n  </thead>\n  <tbody>\n"
	for line in items[1:]:
		html_code += "    <tr>\n"
		for elt in line:
			A             =					f'{elt:.6f}' if isinstance(UpperCamelCase__				,       UpperCamelCase__    ) else str(UpperCamelCase__    )
			html_code += f'      <td>{elt}</td>\n'
		html_code += "    </tr>\n"
	html_code += "  </tbody>\n</table><p>"
	return html_code






class    _UpperCamelCase     :

				"""simple docstring"""







				lowerCAmelCase					=			5
				lowerCAmelCase					=			0.2

				def __init__(    self					, a__					, a__ = None					, a__ = True					, a__ = None					, a__ = 300					, )						->					List[Any]:
					A             =					total
					A             =					"""""" if prefix is None else prefix
					A             =					leave
					A             =					parent
					A             =					width
					A             =					None
					A             =					None
					A             =					None

				def   _UpperCAmelCase       (    self					, a__					, a__ = False					, a__ = None )						->					List[str]:
					A             =					value
					if comment is not None:
						A             =					comment
					if self.last_value is None:
						A             =					A             =					time.time()
						A             =					A             =					value
						A             =					A             =					None
						A             =					self.warmup
						A             =					1
						self.update_bar(a__ )
					elif value <= self.last_value and not force_update:
						return
					elif force_update or self.first_calls > 0 or value >= min(self.last_value + self.wait_for					, self.total ):
						if self.first_calls > 0:
							self.first_calls -= 1
						A             =					time.time()
						A             =					current_time - self.start_time
						# We could have value = self.start_value if the update is called twixe with the same start value.
						if value > self.start_value:
							A             =					self.elapsed_time / (value - self.start_value)
						else:
							A             =					None
						if value >= self.total:
							A             =					self.total
							A             =					None
							if not self.leave:
								self.close()
						elif self.average_time_per_item is not None:
							A             =					self.average_time_per_item * (self.total - value)
						self.update_bar(a__ )
						A             =					value
						A             =					current_time
						if self.average_time_per_item is None:
							A             =					1
						else:
							A             =					max(int(self.update_every / self.average_time_per_item )					, 1 )

				def   _UpperCAmelCase       (    self					, a__					, a__=None )						->					Union[str, Any]:
					A             =					""" """ * (len(str(self.total ) ) - len(str(a__ ) )) + str(a__ )
					if self.elapsed_time is None:
						A             =					f'[{spaced_value}/{self.total} : < :'
					elif self.predicted_remaining is None:
						A             =					f'[{spaced_value}/{self.total} {format_time(self.elapsed_time )}'
					else:
						A             =					(
						    f'[{spaced_value}/{self.total} {format_time(self.elapsed_time )} <'
						    f' {format_time(self.predicted_remaining )}'
						)
						self.label += f', {1/self.average_time_per_item:.2f} it/s'
					self.label += "]" if self.comment is None or len(self.comment ) == 0 else f', {self.comment}]'
					self.display()

				def   _UpperCAmelCase       (    self )						->					int:
					A             =					html_progress_bar(self.value					, self.total					, self.prefix					, self.label					, self.width )
					if self.parent is not None:
						# If this is a child bar, the parent will take care of the display.
						self.parent.display()
						return
					if self.output is None:
						A             =					disp.display(disp.HTML(self.html_code )					, display_id=a__ )
					else:
						self.output.update(disp.HTML(self.html_code ) )

				def   _UpperCAmelCase       (    self )						->					int:
					if self.parent is None and self.output is not None:
						self.output.update(disp.HTML("""""" ) )






class    _UpperCamelCase     (       __snake_case					):

				"""simple docstring"""







				def __init__(    self					, a__					, a__=None )						->					Dict:
					super().__init__(a__ )
					A             =					None if column_names is None else [column_names]
					A             =					None

				def   _UpperCAmelCase       (    self )						->					Tuple:
					A             =					html_progress_bar(self.value					, self.total					, self.prefix					, self.label					, self.width )
					if self.inner_table is not None:
						self.html_code += text_to_html_table(self.inner_table )
					if self.child_bar is not None:
						self.html_code += self.child_bar.html_code
					if self.output is None:
						A             =					disp.display(disp.HTML(self.html_code )					, display_id=a__ )
					else:
						self.output.update(disp.HTML(self.html_code ) )

				def   _UpperCAmelCase       (    self					, a__ )						->					Tuple:
					if self.inner_table is None:
						A             =					[list(values.keys() ), list(values.values() )]
					else:
						A             =					self.inner_table[0]
						if len(self.inner_table ) == 1:
							# We give a chance to update the column names at the first iteration
							for key in values.keys():
								if key not in columns:
									columns.append(a__ )
							A             =					columns
						self.inner_table.append([values[c] for c in columns] )

				def   _UpperCAmelCase       (    self					, a__					, a__=None					, a__=300 )						->					Dict:
					A             =					NotebookProgressBar(a__					, prefix=a__					, parent=self					, width=a__ )
					return self.child_bar

				def   _UpperCAmelCase       (    self )						->					Tuple:
					A             =					None
					self.display()






class    _UpperCamelCase     (       __snake_case					):

				"""simple docstring"""







				def __init__(    self )						->					Tuple:
					A             =					None
					A             =					None
					A             =					False

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, **a__ )						->					Optional[int]:
					A             =					"""Epoch""" if args.evaluation_strategy == IntervalStrategy.EPOCH else """Step"""
					A             =					0
					A             =					0
					A             =					[self.first_column] + ["""Training Loss"""]
					if args.evaluation_strategy != IntervalStrategy.NO:
						column_names.append("""Validation Loss""" )
					A             =					NotebookTrainingTracker(state.max_steps					, a__ )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, **a__ )						->					List[str]:
					A             =					int(state.epoch ) if int(state.epoch ) == state.epoch else f'{state.epoch:.2f}'
					self.training_tracker.update(
					    state.global_step + 1					, comment=f'Epoch {epoch}/{state.num_train_epochs}'					, force_update=self._force_next_update					, )
					A             =					False

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__=None					, **a__ )						->					str:
					if not has_length(a__ ):
						return
					if self.prediction_bar is None:
						if self.training_tracker is not None:
							A             =					self.training_tracker.add_child(len(a__ ) )
						else:
							A             =					NotebookProgressBar(len(a__ ) )
						self.prediction_bar.update(1 )
					else:
						self.prediction_bar.update(self.prediction_bar.value + 1 )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, **a__ )						->					Union[str, Any]:
					if self.prediction_bar is not None:
						self.prediction_bar.close()
					A             =					None

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__=None					, **a__ )						->					int:
					# Only for when there is no evaluation
					if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
						A             =					{"""Training Loss""": logs["""loss"""]}
						# First column is necessarily Step sine we're not in epoch eval strategy
						A             =					state.global_step
						self.training_tracker.write_line(a__ )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__=None					, **a__ )						->					str:
					if self.training_tracker is not None:
						A             =					{"""Training Loss""": """No log""", """Validation Loss""": """No log"""}
						for log in reversed(state.log_history ):
							if "loss" in log:
								A             =					log["""loss"""]
								break

						if self.first_column == "Epoch":
							A             =					int(state.epoch )
						else:
							A             =					state.global_step
						A             =					"""eval"""
						for k in metrics:
							if k.endswith("""_loss""" ):
								A             =					re.sub(r"""\_loss$"""					, """"""					, a__ )
						A             =					metrics.pop("""total_flos"""					, a__ )
						A             =					metrics.pop("""epoch"""					, a__ )
						A             =					metrics.pop(f'{metric_key_prefix}_runtime'					, a__ )
						A             =					metrics.pop(f'{metric_key_prefix}_samples_per_second'					, a__ )
						A             =					metrics.pop(f'{metric_key_prefix}_steps_per_second'					, a__ )
						A             =					metrics.pop(f'{metric_key_prefix}_jit_compilation_time'					, a__ )
						for k, v in metrics.items():
							if k == f'{metric_key_prefix}_loss':
								A             =					v
							else:
								A             =					k.split("""_""" )
								A             =					""" """.join([part.capitalize() for part in splits[1:]] )
								A             =					v
						self.training_tracker.write_line(a__ )
						self.training_tracker.remove_child()
						A             =					None
						# Evaluation takes a long time so we should force the next update.
						A             =					True

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, **a__ )						->					Optional[Any]:
					self.training_tracker.update(
					    state.global_step					, comment=f'Epoch {int(state.epoch )}/{state.num_train_epochs}'					, force_update=a__ )
					A             =					None







import argparse

import requests
import torch

# pip3 install salesforce-lavis
# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis
from lavis.models import load_model_and_preprocess
from PIL import Image

from transformers import (
    AutoTokenizer,
    BlipaConfig,
    BlipaForConditionalGeneration,
    BlipaProcessor,
    BlipaVisionConfig,
    BlipImageProcessor,
    OPTConfig,
    TaConfig,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD





def 	_lowerCAmelCase					( )			-> Tuple:





	"""simple docstring"""







	A             =					"""https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png"""
	A             =					Image.open(requests.get(UpperCamelCase__				,       stream=UpperCamelCase__    ).raw    ).convert("""RGB"""    )

	return image





def 	_lowerCAmelCase					( UpperCamelCase__:  Union[str, Any]    )			-> Dict:





	"""simple docstring"""







	A             =					[]
	# fmt: off

	# vision encoder
	rename_keys.append(("""visual_encoder.cls_token""", """vision_model.embeddings.class_embedding""")    )
	rename_keys.append(("""visual_encoder.pos_embed""", """vision_model.embeddings.position_embedding""")    )
	rename_keys.append(("""visual_encoder.patch_embed.proj.weight""", """vision_model.embeddings.patch_embedding.weight""")    )
	rename_keys.append(("""visual_encoder.patch_embed.proj.bias""", """vision_model.embeddings.patch_embedding.bias""")    )
	rename_keys.append(("""ln_vision.weight""", """vision_model.post_layernorm.weight""")    )
	rename_keys.append(("""ln_vision.bias""", """vision_model.post_layernorm.bias""")    )

	for i in range(config.vision_config.num_hidden_layers    ):
		rename_keys.append((f'visual_encoder.blocks.{i}.norm1.weight', f'vision_model.encoder.layers.{i}.layer_norm1.weight')    )
		rename_keys.append((f'visual_encoder.blocks.{i}.norm1.bias', f'vision_model.encoder.layers.{i}.layer_norm1.bias')    )
		rename_keys.append((f'visual_encoder.blocks.{i}.norm2.weight', f'vision_model.encoder.layers.{i}.layer_norm2.weight')    )
		rename_keys.append((f'visual_encoder.blocks.{i}.norm2.bias', f'vision_model.encoder.layers.{i}.layer_norm2.bias')    )
		rename_keys.append((f'visual_encoder.blocks.{i}.attn.qkv.weight', f'vision_model.encoder.layers.{i}.self_attn.qkv.weight')    )
		rename_keys.append((f'visual_encoder.blocks.{i}.attn.proj.weight', f'vision_model.encoder.layers.{i}.self_attn.projection.weight',)    )
		rename_keys.append((f'visual_encoder.blocks.{i}.attn.proj.bias', f'vision_model.encoder.layers.{i}.self_attn.projection.bias')    )
		rename_keys.append((f'visual_encoder.blocks.{i}.mlp.fc1.weight', f'vision_model.encoder.layers.{i}.mlp.fc1.weight')    )
		rename_keys.append((f'visual_encoder.blocks.{i}.mlp.fc1.bias', f'vision_model.encoder.layers.{i}.mlp.fc1.bias')    )
		rename_keys.append((f'visual_encoder.blocks.{i}.mlp.fc2.weight', f'vision_model.encoder.layers.{i}.mlp.fc2.weight')    )
		rename_keys.append((f'visual_encoder.blocks.{i}.mlp.fc2.bias', f'vision_model.encoder.layers.{i}.mlp.fc2.bias')    )

	# QFormer
	rename_keys.append(("""Qformer.bert.embeddings.LayerNorm.weight""", """qformer.layernorm.weight""")    )
	rename_keys.append(("""Qformer.bert.embeddings.LayerNorm.bias""", """qformer.layernorm.bias""")    )

	# fmt: on
	return rename_keys





def 	_lowerCAmelCase					( UpperCamelCase__:  Tuple				,       UpperCamelCase__:  List[Any]				,       UpperCamelCase__:  Union[str, Any]    )			-> Optional[int]:





	"""simple docstring"""







	A             =					dct.pop(UpperCamelCase__    )
	A             =					val





def 	_lowerCAmelCase					( UpperCamelCase__:  List[Any]				,       UpperCamelCase__:  Union[str, Any]    )			-> Tuple:





	"""simple docstring"""







	for i in range(config.vision_config.num_hidden_layers    ):
		# read in original q and v biases
		A             =					state_dict.pop(f'visual_encoder.blocks.{i}.attn.q_bias'    )
		A             =					state_dict.pop(f'visual_encoder.blocks.{i}.attn.v_bias'    )

		# next, set bias in the state dict
		A             =					torch.cat((q_bias, torch.zeros_like(UpperCamelCase__				,       requires_grad=UpperCamelCase__    ), v_bias)    )
		A             =					qkv_bias





def 	_lowerCAmelCase					( UpperCamelCase__:  str				,       UpperCamelCase__:  Tuple    )			-> Dict:





	"""simple docstring"""







	A             =					3_64 if """coco""" in model_name else 2_24
	A             =					BlipaVisionConfig(image_size=UpperCamelCase__    ).to_dict()

	# make sure the models have proper bos_token_id and eos_token_id set (important for generation)
	# seems like flan-T5 models don't have bos_token_id properly set?
	if "opt-2.7b" in model_name:
		A             =					OPTConfig.from_pretrained("""facebook/opt-2.7b"""				,       eos_token_id=UpperCamelCase__    ).to_dict()
	elif "opt-6.7b" in model_name:
		A             =					OPTConfig.from_pretrained("""facebook/opt-6.7b"""				,       eos_token_id=UpperCamelCase__    ).to_dict()
	elif "t5-xl" in model_name:
		A             =					TaConfig.from_pretrained("""google/flan-t5-xl"""				,       dense_act_fn="""gelu"""				,       bos_token_id=1    ).to_dict()
	elif "t5-xxl" in model_name:
		A             =					TaConfig.from_pretrained("""google/flan-t5-xxl"""				,       dense_act_fn="""gelu"""				,       bos_token_id=1    ).to_dict()

	A             =					BlipaConfig(vision_config=UpperCamelCase__				,       text_config=UpperCamelCase__    )

	return config, image_size





@torch.no_grad()
def 	_lowerCAmelCase					( UpperCamelCase__:  str				,       UpperCamelCase__:  Optional[Any]=None				,       UpperCamelCase__:  Tuple=False    )			-> List[str]:





	"""simple docstring"""







	A             =					(
	    AutoTokenizer.from_pretrained("""facebook/opt-2.7b"""    )
	    if """opt""" in model_name
	    else AutoTokenizer.from_pretrained("""google/flan-t5-xl"""    )
	)
	A             =					tokenizer("""\n"""				,       add_special_tokens=UpperCamelCase__    ).input_ids[0]
	A       ,      A             =					get_blipa_config(UpperCamelCase__				,       eos_token_id=UpperCamelCase__    )

	A             =					BlipaForConditionalGeneration(UpperCamelCase__    ).eval()

	A             =					{
	    """blip2-opt-2.7b""": ("""blip2_opt""", """pretrain_opt2.7b"""),
	    """blip2-opt-6.7b""": ("""blip2_opt""", """pretrain_opt6.7b"""),
	    """blip2-opt-2.7b-coco""": ("""blip2_opt""", """caption_coco_opt2.7b"""),
	    """blip2-opt-6.7b-coco""": ("""blip2_opt""", """caption_coco_opt6.7b"""),
	    """blip2-flan-t5-xl""": ("""blip2_t5""", """pretrain_flant5xl"""),
	    """blip2-flan-t5-xl-coco""": ("""blip2_t5""", """caption_coco_flant5xl"""),
	    """blip2-flan-t5-xxl""": ("""blip2_t5""", """pretrain_flant5xxl"""),
	}

	A       ,      A             =					model_name_to_original[model_name]

	# load original model
	print("""Loading original model..."""    )
	A             =					"""cuda""" if torch.cuda.is_available() else """cpu"""
	A       ,      A       ,      A             =					load_model_and_preprocess(
	    name=UpperCamelCase__				,       model_type=UpperCamelCase__				,       is_eval=UpperCamelCase__				,       device=UpperCamelCase__    )
	original_model.eval()
	print("""Done!"""    )

	# update state dict keys
	A             =					original_model.state_dict()
	A             =					create_rename_keys(UpperCamelCase__    )
	for src, dest in rename_keys:
		rename_key(UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__    )

	# some keys can be renamed efficiently
	for key, val in state_dict.copy().items():
		A             =					state_dict.pop(UpperCamelCase__    )
		if key.startswith("""Qformer.bert"""    ):
			A             =					key.replace("""Qformer.bert"""				,       """qformer"""    )
		if "attention.self" in key:
			A             =					key.replace("""self"""				,       """attention"""    )
		if "opt_proj" in key:
			A             =					key.replace("""opt_proj"""				,       """language_projection"""    )
		if "t5_proj" in key:
			A             =					key.replace("""t5_proj"""				,       """language_projection"""    )
		if key.startswith("""opt"""    ):
			A             =					key.replace("""opt"""				,       """language"""    )
		if key.startswith("""t5"""    ):
			A             =					key.replace("""t5"""				,       """language"""    )
		A             =					val

	# read in qv biases
	read_in_q_v_bias(UpperCamelCase__				,       UpperCamelCase__    )

	A       ,      A             =					hf_model.load_state_dict(UpperCamelCase__				,       strict=UpperCamelCase__    )
	assert len(UpperCamelCase__    ) == 0
	assert unexpected_keys == ["qformer.embeddings.position_ids"]

	A             =					load_demo_image()
	A             =					vis_processors["""eval"""](UpperCamelCase__    ).unsqueeze(0    ).to(UpperCamelCase__    )
	A             =					tokenizer(["""\n"""]				,       return_tensors="""pt"""    ).input_ids.to(UpperCamelCase__    )

	# create processor
	A             =					BlipImageProcessor(
	    size={"""height""": image_size, """width""": image_size}				,       image_mean=UpperCamelCase__				,       image_std=UpperCamelCase__    )
	A             =					BlipaProcessor(image_processor=UpperCamelCase__				,       tokenizer=UpperCamelCase__    )
	A             =					processor(images=UpperCamelCase__				,       return_tensors="""pt"""    ).pixel_values.to(UpperCamelCase__    )

	# make sure processor creates exact same pixel values
	assert torch.allclose(UpperCamelCase__				,       UpperCamelCase__    )

	original_model.to(UpperCamelCase__    )
	hf_model.to(UpperCamelCase__    )
	with torch.no_grad():
		if "opt" in model_name:
			A             =					original_model({"""image""": original_pixel_values, """text_input""": [""""""]}    ).logits
			A             =					hf_model(UpperCamelCase__				,       UpperCamelCase__    ).logits
		else:
			A             =					original_model(
			    {"""image""": original_pixel_values, """text_input""": ["""\n"""], """text_output""": ["""\n"""]}    ).logits
			A             =					input_ids.masked_fill(input_ids == tokenizer.pad_token_id				,       -1_00    )
			A             =					hf_model(UpperCamelCase__				,       UpperCamelCase__				,       labels=UpperCamelCase__    ).logits

	assert original_logits.shape == logits.shape
	print("""First values of original logits:"""				,       original_logits[0, :3, :3]    )
	print("""First values of HF logits:"""				,       logits[0, :3, :3]    )

	# assert values
	if model_name == "blip2-flan-t5-xl":
		A             =					torch.tensor(
		    [[-41.58_50, -4.44_40, -8.99_22], [-47.43_22, -5.91_43, -1.73_40]]				,       device=UpperCamelCase__    )
		assert torch.allclose(logits[0, :3, :3]				,       UpperCamelCase__				,       atol=1e-4    )
	elif model_name == "blip2-flan-t5-xl-coco":
		A             =					torch.tensor(
		    [[-57.01_09, -9.89_67, -12.62_80], [-68.65_78, -12.71_91, -10.50_65]]				,       device=UpperCamelCase__    )
	else:
		# cast to same type
		A             =					logits.dtype
		assert torch.allclose(original_logits.to(UpperCamelCase__    )				,       UpperCamelCase__				,       atol=1e-2    )
	print("""Looks ok!"""    )

	print("""Generating a caption..."""    )
	A             =					""""""
	A             =					tokenizer(UpperCamelCase__				,       return_tensors="""pt"""    ).input_ids.to(UpperCamelCase__    )

	A             =					original_model.generate({"""image""": original_pixel_values}    )
	A             =					hf_model.generate(
	    UpperCamelCase__				,       UpperCamelCase__				,       do_sample=UpperCamelCase__				,       num_beams=5				,       max_length=30				,       min_length=1				,       top_p=0.9				,       repetition_penalty=1.0				,       length_penalty=1.0				,       temperature=1				,       )
	print("""Original generation:"""				,       UpperCamelCase__    )
	A             =					input_ids.shape[1]
	A             =					processor.batch_decode(outputs[:, prompt_length:]				,       skip_special_tokens=UpperCamelCase__    )
	A             =					[text.strip() for text in output_text]
	print("""HF generation:"""				,       UpperCamelCase__    )

	if pytorch_dump_folder_path is not None:
		processor.save_pretrained(UpperCamelCase__    )
		hf_model.save_pretrained(UpperCamelCase__    )

	if push_to_hub:
		processor.push_to_hub(f'nielsr/{model_name}'    )
		hf_model.push_to_hub(f'nielsr/{model_name}'    )


if __name__ == "__main__":
				_lowercase							:   List[Any]						=						argparse.ArgumentParser()
				_lowercase							:   List[str]						=						[
				    "blip2-opt-2.7b",
				    "blip2-opt-6.7b",
				    "blip2-opt-2.7b-coco",
				    "blip2-opt-6.7b-coco",
				    "blip2-flan-t5-xl",
				    "blip2-flan-t5-xl-coco",
				    "blip2-flan-t5-xxl",
				]
				parser.add_argument(
				    "--model_name",
				    default="blip2-opt-2.7b",
				    choices=choices,
				    type=str,
				    help="Path to hf config.json of model to convert",
				)
				parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
				parser.add_argument(
				    "--push_to_hub",
				    action="store_true",
				    help="Whether to push the model and processor to the hub after converting",
				)

				_lowercase							:   Tuple						=						parser.parse_args()

				convert_blipa_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)



