






import argparse

# utilities to import the model weights and config file
import os
import pickle as pkl

# PyTorch + new model classes
import torch
from torch import nn

from transformers import AutoTokenizer, MegaConfig, MegaForMaskedLM


# import the EncoderLayer class used to pretrain
# !! NOTE !! this requires the version of fairseq that is built when you install the Mega source
try:
       from fairseq.modules.mega_layer import MegaEncoderLayer
except ImportError:
       raise ImportError("You need to install the version of fairseq from the Mega repo!")
class 					a					(				nn.Module     ):



      """simple docstring"""


      def __init__(   self      :    str	,   __lowercase      :    Optional[Any]	,   __lowercase      :    Tuple	,   __lowercase      :    Optional[Any]      )							->   List[str]:
        super().__init__()
        __UpperCAmelCase							:			Tuple     =						mega_args
        __UpperCAmelCase							:			Any     =						nn.Embedding(a_	,   self.mega_args.encoder_embed_dim      )
        __UpperCAmelCase							:			List[str]     =						nn.ModuleList([MegaEncoderLayer(self.mega_args      ) for _ in range(a_      )]      )
        __UpperCAmelCase							:			Optional[int]     =						depth




      def 			UpperCAmelCase   (   self      :    Optional[Any]	,   __lowercase      :    List[str]	,   __lowercase      :    Any	,   __lowercase      :    Any=True	,   __lowercase      :    int=0      )							->   Dict:



        if batch_first:
          __UpperCAmelCase							:			Dict     =						input_ids.T

        # to make things more confusing, Mega expects the attention mask to
        # be (batch, time), but with values of 0 (normal token) and 1 (ignore token)
        # which is the opposite of what HF returns
        if ignore_mask_value == 0:
          __UpperCAmelCase							:			int     =						1 - attention_mask

        # get token embeddings from IDs
        __UpperCAmelCase							:			Optional[int]     =						self.embedding_layer(a_      )

        # pass through the Mega layers
        # input is (time, batch, encoder dim) and output is the same
        for encoder in self.encoders:
          __UpperCAmelCase							:			Optional[int]     =						encoder(a_	,   a_      )

        # return according to the shape specified
        if batch_first:
          # (T, B, H) --> (B, T, H)
          return torch.transpose(a_	,   0	,   1      )
        else:
          return embeds


class 					a					(				nn.Module     ):



      """simple docstring"""


      def __init__(   self      :    str	,   __lowercase      :    List[Any]	,   __lowercase      :    Any	,   __lowercase      :    str      )							->   str:
        super().__init__()
        __UpperCAmelCase							:			str     =						MegaLM(a_	,   a_	,   a_      )
        __UpperCAmelCase							:			Optional[Any]     =						nn.Linear(mega_args.encoder_embed_dim	,   a_      )
        __UpperCAmelCase							:			Optional[int]     =						nn.Dropout(p=0.1      )




      def 			UpperCAmelCase   (   self      :    Dict	,   __lowercase      :    Tuple	,   __lowercase      :    str	,   __lowercase      :    int=True	,   __lowercase      :    int=0      )							->   Any:
        __UpperCAmelCase							:			Optional[Any]     =						self.mega(a_	,   a_	,   a_	,   a_      )
        return self.mlm_head(self.dropout(a_      )      )






def        lowerCamelCase__   (					__lowerCamelCase    :  Optional[int]						,	__lowerCamelCase    :  List[str]						,	__lowerCamelCase    :  List[Any]	):







  with open(os.path.join(_UpperCamelCase						,	"""model_args.pkl"""	)						,	"""rb"""	) as f:
    __UpperCAmelCase							:			Union[str, Any]     =						pkl.load(_UpperCamelCase	)

  # load the original encoder
  __UpperCAmelCase							:			Union[str, Any]     =						OriginalMegaForMaskedLM(**_UpperCamelCase	).eval()

  # load its weights
  print(
      """Original Mega encoder:"""						,	original_mlm.mega.load_state_dict(
          torch.load(os.path.join(_UpperCamelCase						,	"""encoder_weights.pt"""	)						,	map_location="""cpu"""	)	)						,	)
  print(
      """Original Mega MLM layer:"""						,	original_mlm.mlm_head.load_state_dict(
          torch.load(os.path.join(_UpperCamelCase						,	"""mlm_head_weights.pt"""	)						,	map_location="""cpu"""	)	)						,	)

  # create a new config from the old one
  __UpperCAmelCase							:			str     =						MegaConfig(
      num_hidden_layers=mega_original_args["""depth"""]						,	vocab_size=mega_original_args["""vocab_size"""]						,	hidden_size=mega_original_args["""mega_args"""].encoder_embed_dim						,	shared_representation_size=mega_original_args["""mega_args"""].encoder_z_dim						,	intermediate_size=mega_original_args["""mega_args"""].encoder_hidden_dim						,	ema_projection_size=mega_original_args["""mega_args"""].encoder_n_dim						,	dropout_prob=mega_original_args["""mega_args"""].dropout						,	attention_probs_dropout_prob=mega_original_args["""mega_args"""].attention_dropout						,	hidden_dropout_prob=mega_original_args["""mega_args"""].hidden_dropout						,	activation=mega_original_args["""mega_args"""].activation_fn						,	attention_activation=mega_original_args["""mega_args"""].attention_activation_fn						,	bidirectional=mega_original_args["""mega_args"""].bidirectional						,	use_chunking=mega_original_args["""mega_args"""].encoder_chunk_size > 0						,	chunk_size=mega_original_args["""mega_args"""].encoder_chunk_size						,	truncation=mega_original_args["""mega_args"""].truncation_length						,	normalization_type=mega_original_args["""mega_args"""].normalization_type						,	normalize_before_mega=_UpperCamelCase						,	norm_affine=_UpperCamelCase						,	use_feature_dropout=mega_original_args["""mega_args"""].feature_dropout						,	relative_positional_bias=mega_original_args["""mega_args"""].rel_pos_bias						,	max_positions=mega_original_args["""mega_args"""].max_source_positions						,	nffn_hidden_size=mega_original_args["""mega_args"""].encoder_ffn_embed_dim						,	normalize_before_ffn=mega_original_args["""mega_args"""].normalize_before						,	nffn_activation_dropout_prob=0.0						,	add_token_type_embeddings=_UpperCamelCase						,	add_lm_hidden_dense_layer=_UpperCamelCase						,	)

  __UpperCAmelCase							:			List[str]     =						MegaForMaskedLM(_UpperCamelCase	).eval()

  # the originl checkpoint just uses nn.Embedding for the word embeddings
  # we use a wrapper module for embeddings to add support for positional embeddings
  __UpperCAmelCase							:			Dict     =						original_mlm.mega.embedding_layer.weight

  # modify the state dictionary of the original checkpoint to account for naming issues in the Hugging Face
  # ecosystem -- any names containing "beta" or "gamma" aren't safe to use and are renamed upon _load_pretrained,
  # also renaming previously confusing parameter names
  __UpperCAmelCase							:			Optional[Any]     =						original_mlm.mega.encoders.state_dict()
  __UpperCAmelCase							:			int     =						{}
  for module_name in original_state_dict.keys():
    __UpperCAmelCase							:			Any     =						None
    # have to handle gamma, beta, and alpha differently due to their use
    # in multiple modules within the original repository;
    # beta is used in EMA, MovingAverageGatedAttention, and RotaryRelativePositionalBias, and must be renamed due to flax/tf weights
    # the EMA sublayer was renamed from "move" to "ema_gate" for readability, so that is also done here
    if "beta" in module_name:
      # EMA sub-layers were always called "move" in the original repo
      if "move.beta" in module_name:
        __UpperCAmelCase							:			Dict     =						module_name.replace("""move.beta"""						,	"""ema_gate.ema_expansion_matrix"""	)
      elif "mega_layer.beta" in module_name:
        __UpperCAmelCase							:			Any     =						module_name.replace("""beta"""						,	"""qk_bias"""	)
      else:
        __UpperCAmelCase							:			Optional[Any]     =						module_name.replace("""beta"""						,	"""b_param"""	)
        # beta is used in EMA and MovingAverageGatedAttention, and must be renamed due to flax/tf weights
    elif "gamma" in module_name:
      if "move.gamma" in module_name:
        __UpperCAmelCase							:			int     =						module_name.replace("""move.gamma"""						,	"""ema_gate.kernel_projection_matrix"""	)
      elif "mega_layer.gamma" in module_name:
        __UpperCAmelCase							:			Any     =						module_name.replace("""gamma"""						,	"""qk_weight"""	)
      else:
        __UpperCAmelCase							:			Optional[Any]     =						module_name.replace("""gamma"""						,	"""g_param"""	)
        # alpha is used in EMA and positional bias; renaming to improve readability
    elif "move.alpha" in module_name:
      __UpperCAmelCase							:			str     =						module_name.replace("""move.alpha"""						,	"""ema_gate.decay_factor"""	)
    # delta is only used in EMA; renaming to improve readability
    elif "move.delta" in module_name:
      __UpperCAmelCase							:			List[str]     =						module_name.replace("""move.delta"""						,	"""ema_gate.damping_factor"""	)
    # omega is only used in EMA; renaming to improve readability
    elif "omega" in module_name:
      __UpperCAmelCase							:			str     =						module_name.replace("""move.omega"""						,	"""ema_gate.residual_weight"""	)

    if new_module_name:
      __UpperCAmelCase							:			str     =						new_module_name

  if len(_UpperCamelCase	) != 0:
    print(f"""Renaming these keys: {updated_keys.keys()}"""	)
  else:
    print("""No need to rename state dict entries"""	)
  for old, new in updated_keys.items():
    __UpperCAmelCase							:			Any     =						original_state_dict.pop(_UpperCamelCase	)

  # now attempt to load the state dictionary with updated names
  # note that we now call it `mega.layers` instead of `mega.encoders` due to hugging face style
  print("""HF Mega encoder:"""						,	hf_mlm.mega.layers.load_state_dict(_UpperCamelCase	)	)

  # load the MLM head weights directly
  print(
      """HF Mega MLM layer:"""						,	hf_mlm.mlm_head.load_state_dict(
          torch.load(os.path.join(_UpperCamelCase						,	"""mlm_head_weights.pt"""	)						,	map_location="""cpu"""	)	)						,	)

  # test on a randomly generated input sequence
  __UpperCAmelCase							:			Tuple     =						torch.randint(0						,	hf_config.vocab_size						,	size=(4, 256)	)
  __UpperCAmelCase							:			Tuple     =						torch.ones_like(_UpperCamelCase	)
  # mask a few tokens to make sure masking is applied appropriately :)
  __UpperCAmelCase							:			Union[str, Any]     =						0

  # run forward passes
  __UpperCAmelCase							:			List[str]     =						original_mlm(_UpperCamelCase						,	_UpperCamelCase						,	batch_first=_UpperCamelCase						,	ignore_mask_value=0	)
  __UpperCAmelCase							:			Union[str, Any]     =						hf_mlm(_UpperCamelCase						,	_UpperCamelCase	)[0]

  # print shapes and diff
  print(f"""original output {original_output.shape}"""	)
  print(f"""hf output {hf_output.shape}"""	)
  print(f"""max diff: {(original_output - hf_output).max()}"""	)  # 0.0
  __UpperCAmelCase							:			Optional[Any]     =						torch.allclose(_UpperCamelCase						,	_UpperCamelCase						,	atol=1E-3	)

  if success:
    print("""Yay!"""	)
    hf_mlm.save_pretrained(_UpperCamelCase	)
  else:
    raise RuntimeError(f"""Something\'s broken :(\nOriginal:\n{original_output}\n\nHF\n{hf_output}\n{hf_mlm}"""	)

  if includes_tokenizer:
    print("""Transferring tokenizer"""	)
    __UpperCAmelCase							:			Union[str, Any]     =						AutoTokenizer.from_pretrained(_UpperCamelCase	)
    tokenizer.save_pretrained(_UpperCamelCase	)


if __name__ == "__main__":
       a	: Dict      =				argparse.ArgumentParser()

       parser.add_argument(
           "--pretrained_checkpoint_path",
           default=None,
           type=str,
           required=True,
           help="Point to the directory containing your model weights using the official Mega repo",
       )

       parser.add_argument(
           "--output_path", default=None, type=str, required=True, help="Location to save the Hugging Face version"
       )

       parser.add_argument(
           "--includes_tokenizer",
           action="store_true",
           help="Use this flag if there is a Hugging Face tokenizer in the original checkpoint repo",
       )

       a	: List[Any]      =				parser.parse_args()

       convert_checkpoint_to_huggingface(args.pretrained_checkpoint_path, args.output_path, args.includes_tokenizer)










import argparse

import requests
import torch
from PIL import Image

from transformers import (
    CLIPSegConfig,
    CLIPSegForImageSegmentation,
    CLIPSegProcessor,
    CLIPSegTextConfig,
    CLIPSegVisionConfig,
    CLIPTokenizer,
    ViTImageProcessor,
)






def        lowerCamelCase__   (					__lowerCamelCase    :  int	):
  __UpperCAmelCase							:			Any     =						CLIPSegTextConfig()
  __UpperCAmelCase							:			Optional[int]     =						CLIPSegVisionConfig(patch_size=16	)

  __UpperCAmelCase							:			List[str]     =						True if """refined""" in model_name else False
  __UpperCAmelCase							:			List[Any]     =						16 if """rd16""" in model_name else 64

  __UpperCAmelCase							:			Tuple     =						CLIPSegConfig.from_text_vision_configs(
      __lowerCamelCase						,	__lowerCamelCase						,	use_complex_transposed_convolution=__lowerCamelCase						,	reduce_dim=__lowerCamelCase						,	)
  return config






def        lowerCamelCase__   (					__lowerCamelCase    :  str	):
  # update prefixes
  if "clip_model" in name:
    __UpperCAmelCase							:			int     =						name.replace("""clip_model"""						,	"""clip"""	)
  if "transformer" in name:
    if "visual" in name:
      __UpperCAmelCase							:			List[Any]     =						name.replace("""visual.transformer"""						,	"""vision_model"""	)
    else:
      __UpperCAmelCase							:			str     =						name.replace("""transformer"""						,	"""text_model"""	)
  if "resblocks" in name:
    __UpperCAmelCase							:			Union[str, Any]     =						name.replace("""resblocks"""						,	"""encoder.layers"""	)
  if "ln_1" in name:
    __UpperCAmelCase							:			List[str]     =						name.replace("""ln_1"""						,	"""layer_norm1"""	)
  if "ln_2" in name:
    __UpperCAmelCase							:			str     =						name.replace("""ln_2"""						,	"""layer_norm2"""	)
  if "c_fc" in name:
    __UpperCAmelCase							:			Tuple     =						name.replace("""c_fc"""						,	"""fc1"""	)
  if "c_proj" in name:
    __UpperCAmelCase							:			Union[str, Any]     =						name.replace("""c_proj"""						,	"""fc2"""	)
  if "attn" in name and "self" not in name:
    __UpperCAmelCase							:			Tuple     =						name.replace("""attn"""						,	"""self_attn"""	)
  # text encoder
  if "token_embedding" in name:
    __UpperCAmelCase							:			Any     =						name.replace("""token_embedding"""						,	"""text_model.embeddings.token_embedding"""	)
  if "positional_embedding" in name and "visual" not in name:
    __UpperCAmelCase							:			Dict     =						name.replace("""positional_embedding"""						,	"""text_model.embeddings.position_embedding.weight"""	)
  if "ln_final" in name:
    __UpperCAmelCase							:			List[str]     =						name.replace("""ln_final"""						,	"""text_model.final_layer_norm"""	)
  # vision encoder
  if "visual.class_embedding" in name:
    __UpperCAmelCase							:			Any     =						name.replace("""visual.class_embedding"""						,	"""vision_model.embeddings.class_embedding"""	)
  if "visual.conv1" in name:
    __UpperCAmelCase							:			str     =						name.replace("""visual.conv1"""						,	"""vision_model.embeddings.patch_embedding"""	)
  if "visual.positional_embedding" in name:
    __UpperCAmelCase							:			Any     =						name.replace("""visual.positional_embedding"""						,	"""vision_model.embeddings.position_embedding.weight"""	)
  if "visual.ln_pre" in name:
    __UpperCAmelCase							:			List[Any]     =						name.replace("""visual.ln_pre"""						,	"""vision_model.pre_layrnorm"""	)
  if "visual.ln_post" in name:
    __UpperCAmelCase							:			Any     =						name.replace("""visual.ln_post"""						,	"""vision_model.post_layernorm"""	)
  # projection layers
  if "visual.proj" in name:
    __UpperCAmelCase							:			Any     =						name.replace("""visual.proj"""						,	"""visual_projection.weight"""	)
  if "text_projection" in name:
    __UpperCAmelCase							:			List[str]     =						name.replace("""text_projection"""						,	"""text_projection.weight"""	)
  # decoder
  if "trans_conv" in name:
    __UpperCAmelCase							:			str     =						name.replace("""trans_conv"""						,	"""transposed_convolution"""	)
  if "film_mul" in name or "film_add" in name or "reduce" in name or "transposed_convolution" in name:
    __UpperCAmelCase							:			int     =						"""decoder.""" + name
  if "blocks" in name:
    __UpperCAmelCase							:			List[str]     =						name.replace("""blocks"""						,	"""decoder.layers"""	)
  if "linear1" in name:
    __UpperCAmelCase							:			str     =						name.replace("""linear1"""						,	"""mlp.fc1"""	)
  if "linear2" in name:
    __UpperCAmelCase							:			str     =						name.replace("""linear2"""						,	"""mlp.fc2"""	)
  if "norm1" in name and "layer_" not in name:
    __UpperCAmelCase							:			int     =						name.replace("""norm1"""						,	"""layer_norm1"""	)
  if "norm2" in name and "layer_" not in name:
    __UpperCAmelCase							:			Union[str, Any]     =						name.replace("""norm2"""						,	"""layer_norm2"""	)

  return name






def        lowerCamelCase__   (					__lowerCamelCase    :  Union[str, Any]						,	__lowerCamelCase    :  int	):
  for key in orig_state_dict.copy().keys():
    __UpperCAmelCase							:			Optional[Any]     =						orig_state_dict.pop(__lowerCamelCase	)

    if key.startswith("""clip_model"""	) and "attn.in_proj" in key:
      __UpperCAmelCase							:			Dict     =						key.split("""."""	)
      if "visual" in key:
        __UpperCAmelCase							:			List[str]     =						int(key_split[4]	)
        __UpperCAmelCase							:			Union[str, Any]     =						config.vision_config.hidden_size
        __UpperCAmelCase							:			List[Any]     =						"""vision_model"""
      else:
        __UpperCAmelCase							:			Optional[Any]     =						int(key_split[3]	)
        __UpperCAmelCase							:			str     =						config.text_config.hidden_size
        __UpperCAmelCase							:			Optional[Any]     =						"""text_model"""

      if "weight" in key:
        __UpperCAmelCase							:			Optional[Any]     =						val[:dim, :]
        __UpperCAmelCase							:			Any     =						val[
            dim : dim * 2, :
        ]
        __UpperCAmelCase							:			List[str]     =						val[-dim:, :]
      else:
        __UpperCAmelCase							:			List[str]     =						val[:dim]
        __UpperCAmelCase							:			Optional[int]     =						val[dim : dim * 2]
        __UpperCAmelCase							:			List[str]     =						val[-dim:]
    elif "self_attn" in key and "out_proj" not in key:
      __UpperCAmelCase							:			Union[str, Any]     =						key.split("""."""	)
      __UpperCAmelCase							:			List[str]     =						int(key_split[1]	)
      __UpperCAmelCase							:			List[str]     =						config.reduce_dim
      if "weight" in key:
        __UpperCAmelCase							:			Optional[int]     =						val[:dim, :]
        __UpperCAmelCase							:			List[str]     =						val[dim : dim * 2, :]
        __UpperCAmelCase							:			Union[str, Any]     =						val[-dim:, :]
      else:
        __UpperCAmelCase							:			Tuple     =						val[:dim]
        __UpperCAmelCase							:			Any     =						val[dim : dim * 2]
        __UpperCAmelCase							:			int     =						val[-dim:]
    else:
      __UpperCAmelCase							:			List[Any]     =						rename_key(__lowerCamelCase	)
      if "visual_projection" in new_name or "text_projection" in new_name:
        __UpperCAmelCase							:			List[Any]     =						val.T
      __UpperCAmelCase							:			Any     =						val

  return orig_state_dict






def        lowerCamelCase__   (					):
  __UpperCAmelCase							:			Optional[Any]     =						"""http://images.cocodataset.org/val2017/000000039769.jpg"""
  __UpperCAmelCase							:			List[Any]     =						Image.open(requests.get(__lowerCamelCase						,	stream=__lowerCamelCase	).raw	)
  return image






def        lowerCamelCase__   (					__lowerCamelCase    :  Optional[int]						,	__lowerCamelCase    :  Optional[Any]						,	__lowerCamelCase    :  str						,	__lowerCamelCase    :  List[str]	):
  __UpperCAmelCase							:			Optional[Any]     =						get_clipseg_config(__lowerCamelCase	)
  __UpperCAmelCase							:			Tuple     =						CLIPSegForImageSegmentation(__lowerCamelCase	)
  model.eval()

  __UpperCAmelCase							:			Optional[int]     =						torch.load(__lowerCamelCase						,	map_location="""cpu"""	)

  # remove some keys
  for key in state_dict.copy().keys():
    if key.startswith("""model"""	):
      state_dict.pop(__lowerCamelCase						,	__lowerCamelCase	)

    # rename some keys
  __UpperCAmelCase							:			Optional[Any]     =						convert_state_dict(__lowerCamelCase						,	__lowerCamelCase	)
  __UpperCAmelCase   ,				__UpperCAmelCase							:			Optional[Any]     =						model.load_state_dict(__lowerCamelCase						,	strict=__lowerCamelCase	)

  if missing_keys != ["clip.text_model.embeddings.position_ids", "clip.vision_model.embeddings.position_ids"]:
    raise ValueError("""Missing keys that are not expected: {}""".format(__lowerCamelCase	)	)
  if unexpected_keys != ["decoder.reduce.weight", "decoder.reduce.bias"]:
    raise ValueError(f"""Unexpected keys: {unexpected_keys}"""	)

  __UpperCAmelCase							:			Optional[Any]     =						ViTImageProcessor(size=352	)
  __UpperCAmelCase							:			Tuple     =						CLIPTokenizer.from_pretrained("""openai/clip-vit-base-patch32"""	)
  __UpperCAmelCase							:			List[Any]     =						CLIPSegProcessor(image_processor=__lowerCamelCase						,	tokenizer=__lowerCamelCase	)

  __UpperCAmelCase							:			int     =						prepare_img()
  __UpperCAmelCase							:			Optional[Any]     =						["""a glass""", """something to fill""", """wood""", """a jar"""]

  __UpperCAmelCase							:			Union[str, Any]     =						processor(text=__lowerCamelCase						,	images=[image] * len(__lowerCamelCase	)						,	padding="""max_length"""						,	return_tensors="""pt"""	)

  with torch.no_grad():
    __UpperCAmelCase							:			int     =						model(**__lowerCamelCase	)

  # verify values
  __UpperCAmelCase							:			Dict     =						torch.tensor([0.1_1_1_0, -0.1_8_8_2, 0.1_6_4_5]	)
  __UpperCAmelCase							:			Union[str, Any]     =						torch.tensor([0.2_6_9_2, -0.7_1_9_7, -0.1_3_2_8]	)
  if model_name == "clipseg-rd64-refined":
    __UpperCAmelCase							:			str     =						torch.tensor(
        [[-1_0.0_4_0_7, -9.9_4_3_1, -1_0.2_6_4_6], [-9.9_7_5_1, -9.7_0_6_4, -9.9_5_8_6], [-9.6_8_9_1, -9.5_6_4_5, -9.9_6_1_8]]	)
  elif model_name == "clipseg-rd64":
    __UpperCAmelCase							:			List[Any]     =						torch.tensor(
        [[-7.2_8_7_7, -7.2_7_1_1, -7.2_4_6_3], [-7.2_6_5_2, -7.2_7_8_0, -7.2_5_2_0], [-7.2_2_3_9, -7.2_2_0_4, -7.2_0_0_1]]	)
  elif model_name == "clipseg-rd16":
    __UpperCAmelCase							:			str     =						torch.tensor(
        [[-6.3_9_5_5, -6.4_0_5_5, -6.4_1_5_1], [-6.3_9_1_1, -6.4_0_3_3, -6.4_1_0_0], [-6.3_4_7_4, -6.3_7_0_2, -6.3_7_6_2]]	)
  else:
    raise ValueError(f"""Model name {model_name} not supported."""	)

  assert torch.allclose(outputs.logits[0, :3, :3]						,	__lowerCamelCase						,	atol=1E-3	)
  assert torch.allclose(outputs.conditional_embeddings[0, :3]						,	__lowerCamelCase						,	atol=1E-3	)
  assert torch.allclose(outputs.pooled_output[0, :3]						,	__lowerCamelCase						,	atol=1E-3	)
  print("""Looks ok!"""	)

  if pytorch_dump_folder_path is not None:
    print(f"""Saving model and processor to {pytorch_dump_folder_path}"""	)
    model.save_pretrained(__lowerCamelCase	)
    processor.save_pretrained(__lowerCamelCase	)

  if push_to_hub:
    print(f"""Pushing model and processor for {model_name} to the hub"""	)
    model.push_to_hub(f"""CIDAS/{model_name}"""	)
    processor.push_to_hub(f"""CIDAS/{model_name}"""	)


if __name__ == "__main__":
       a	: Optional[Any]      =				argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           "--model_name",
           default="clipseg-rd64",
           type=str,
           choices=["clipseg-rd16", "clipseg-rd64", "clipseg-rd64-refined"],
           help=(
               "Name of the model. Supported models are: clipseg-rd64, clipseg-rd16 and clipseg-rd64-refined (rd meaning"
               " reduce dimension)"
           ),
       )
       parser.add_argument(
           "--checkpoint_path",
           default="/Users/nielsrogge/Documents/CLIPSeg/clip_plus_rd64-uni.pth",
           type=str,
           help=(
               "Path to the original checkpoint. Note that the script assumes that the checkpoint includes both CLIP and"
               " the decoder weights."
           ),
       )
       parser.add_argument(
           "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
       )
       parser.add_argument(
           "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
       )

       a	: int      =				parser.parse_args()
       convert_clipseg_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)


