code: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import argparse
  
  import requests
  import torch
  from PIL import Image
  
  from transformers import (
      CLIPSegConfig,
      CLIPSegForImageSegmentation,
      CLIPSegProcessor,
      CLIPSegTextConfig,
      CLIPSegVisionConfig,
      CLIPTokenizer,
      ViTImageProcessor,
  )
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = CLIPSegTextConfig()
  		_snake_case			 = CLIPSegVisionConfig(patch_size=16						)
  
  		_snake_case			 = True if "refined" in model_name else False
  		_snake_case			 = 16 if "rd16" in model_name else 64
  
  		_snake_case			 = CLIPSegConfig.from_text_vision_configs(
  		    _A		,							_A		,							use_complex_transposed_convolution=_A		,							reduce_dim=_A		,							)
  		return config
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if "clip_model" in name:
  				_snake_case			 = name.replace("clip_model"		,							"clip"						)
  		if "transformer" in name:
  				if "visual" in name:
  						_snake_case			 = name.replace("visual.transformer"		,							"vision_model"						)
  				else:
  						_snake_case			 = name.replace("transformer"		,							"text_model"						)
  		if "resblocks" in name:
  				_snake_case			 = name.replace("resblocks"		,							"encoder.layers"						)
  		if "ln_1" in name:
  				_snake_case			 = name.replace("ln_1"		,							"layer_norm1"						)
  		if "ln_2" in name:
  				_snake_case			 = name.replace("ln_2"		,							"layer_norm2"						)
  		if "c_fc" in name:
  				_snake_case			 = name.replace("c_fc"		,							"fc1"						)
  		if "c_proj" in name:
  				_snake_case			 = name.replace("c_proj"		,							"fc2"						)
  		if "attn" in name and "self" not in name:
  				_snake_case			 = name.replace("attn"		,							"self_attn"						)
  		# text encoder
  		if "token_embedding" in name:
  				_snake_case			 = name.replace("token_embedding"		,							"text_model.embeddings.token_embedding"						)
  		if "positional_embedding" in name and "visual" not in name:
  				_snake_case			 = name.replace("positional_embedding"		,							"text_model.embeddings.position_embedding.weight"						)
  		if "ln_final" in name:
  				_snake_case			 = name.replace("ln_final"		,							"text_model.final_layer_norm"						)
  		# vision encoder
  		if "visual.class_embedding" in name:
  				_snake_case			 = name.replace("visual.class_embedding"		,							"vision_model.embeddings.class_embedding"						)
  		if "visual.conv1" in name:
  				_snake_case			 = name.replace("visual.conv1"		,							"vision_model.embeddings.patch_embedding"						)
  		if "visual.positional_embedding" in name:
  				_snake_case			 = name.replace("visual.positional_embedding"		,							"vision_model.embeddings.position_embedding.weight"						)
  		if "visual.ln_pre" in name:
  				_snake_case			 = name.replace("visual.ln_pre"		,							"vision_model.pre_layrnorm"						)
  		if "visual.ln_post" in name:
  				_snake_case			 = name.replace("visual.ln_post"		,							"vision_model.post_layernorm"						)
  		# projection layers
  		if "visual.proj" in name:
  				_snake_case			 = name.replace("visual.proj"		,							"visual_projection.weight"						)
  		if "text_projection" in name:
  				_snake_case			 = name.replace("text_projection"		,							"text_projection.weight"						)
  		# decoder
  		if "trans_conv" in name:
  				_snake_case			 = 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:
  				_snake_case			 = "decoder." + name
  		if "blocks" in name:
  				_snake_case			 = name.replace("blocks"		,							"decoder.layers"						)
  		if "linear1" in name:
  				_snake_case			 = name.replace("linear1"		,							"mlp.fc1"						)
  		if "linear2" in name:
  				_snake_case			 = name.replace("linear2"		,							"mlp.fc2"						)
  		if "norm1" in name and "layer_" not in name:
  				_snake_case			 = name.replace("norm1"		,							"layer_norm1"						)
  		if "norm2" in name and "layer_" not in name:
  				_snake_case			 = name.replace("norm2"		,							"layer_norm2"						)
  
  		return name
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		for key in orig_state_dict.copy().keys():
  				_snake_case			 = orig_state_dict.pop(_A						)
  
  				if key.startswith("clip_model"						) and "attn.in_proj" in key:
  						_snake_case			 = key.split("."						)
  						if "visual" in key:
  								_snake_case			 = int(key_split[4]						)
  								_snake_case			 = config.vision_config.hidden_size
  								_snake_case			 = "vision_model"
  						else:
  								_snake_case			 = int(key_split[3]						)
  								_snake_case			 = config.text_config.hidden_size
  								_snake_case			 = "text_model"
  
  						if "weight" in key:
  								_snake_case			 = val[:dim, :]
  								_snake_case			 = val[
  								    dim : dim * 2, :
  								]
  								_snake_case			 = val[-dim:, :]
  						else:
  								_snake_case			 = val[:dim]
  								_snake_case			 = val[dim : dim * 2]
  								_snake_case			 = val[-dim:]
  				elif "self_attn" in key and "out_proj" not in key:
  						_snake_case			 = key.split("."						)
  						_snake_case			 = int(key_split[1]						)
  						_snake_case			 = config.reduce_dim
  						if "weight" in key:
  								_snake_case			 = val[:dim, :]
  								_snake_case			 = val[dim : dim * 2, :]
  								_snake_case			 = val[-dim:, :]
  						else:
  								_snake_case			 = val[:dim]
  								_snake_case			 = val[dim : dim * 2]
  								_snake_case			 = val[-dim:]
  				else:
  						_snake_case			 = rename_key(_A						)
  						if "visual_projection" in new_name or "text_projection" in new_name:
  								_snake_case			 = val.T
  						_snake_case			 = val
  
  		return orig_state_dict
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = "http://images.cocodataset.org/val2017/000000039769.jpg"
  		_snake_case			 = Image.open(requests.get(_A		,							stream=_A						).raw						)
  		return image
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_		,							lowercase_		,							lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = get_clipseg_config(_A						)
  		_snake_case			 = CLIPSegForImageSegmentation(_A						)
  		model.eval()
  
  		_snake_case			 = torch.load(_A		,							map_location="cpu"						)
  
  		# remove some keys
  		for key in state_dict.copy().keys():
  				if key.startswith("model"						):
  						state_dict.pop(_A		,							_A						)
  
      # rename some keys
  		_snake_case			 = convert_state_dict(_A		,							_A						)
  		_snake_case ,					_snake_case			 = model.load_state_dict(_A		,							strict=_A						)
  
  		if missing_keys != ["clip.text_model.embeddings.position_ids", "clip.vision_model.embeddings.position_ids"]:
  				raise ValueError("Missing keys that are not expected: {}".format(_A						)						)
  		if unexpected_keys != ["decoder.reduce.weight", "decoder.reduce.bias"]:
  				raise ValueError(f'''Unexpected keys: {unexpected_keys}'''						)
  
  		_snake_case			 = ViTImageProcessor(size=352						)
  		_snake_case			 = CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32"						)
  		_snake_case			 = CLIPSegProcessor(image_processor=_A		,							tokenizer=_A						)
  
  		_snake_case			 = prepare_img()
  		_snake_case			 = ["a glass", "something to fill", "wood", "a jar"]
  
  		_snake_case			 = processor(text=_A		,							images=[image] * len(_A						)		,							padding="max_length"		,							return_tensors="pt"						)
  
  		with torch.no_grad():
  				_snake_case			 = model(**_A						)
  
  		# verify values
  		_snake_case			 = torch.tensor([0.1110, -0.1882, 0.1645]						)
  		_snake_case			 = torch.tensor([0.2692, -0.7197, -0.1328]						)
  		if model_name == "clipseg-rd64-refined":
  				_snake_case			 = torch.tensor(
  				    [[-10.0407, -9.9431, -10.2646], [-9.9751, -9.7064, -9.9586], [-9.6891, -9.5645, -9.9618]]						)
  		elif model_name == "clipseg-rd64":
  				_snake_case			 = torch.tensor(
  				    [[-7.2877, -7.2711, -7.2463], [-7.2652, -7.2780, -7.2520], [-7.2239, -7.2204, -7.2001]]						)
  		elif model_name == "clipseg-rd16":
  				_snake_case			 = torch.tensor(
  				    [[-6.3955, -6.4055, -6.4151], [-6.3911, -6.4033, -6.4100], [-6.3474, -6.3702, -6.3762]]						)
  		else:
  				raise ValueError(f'''Model name {model_name} not supported.'''						)
  
  		assert torch.allclose(outputs.logits[0, :3, :3]		,							_A		,							atol=1e-3						)
  		assert torch.allclose(outputs.conditional_embeddings[0, :3]		,							_A		,							atol=1e-3						)
  		assert torch.allclose(outputs.pooled_output[0, :3]		,							_A		,							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(_A						)
  				processor.save_pretrained(_A						)
  
  		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__":
  						_lowerCamelCase							:		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.'
  						)
  
  						_lowerCamelCase							:		int							=						parser.parse_args()
  						convert_clipseg_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
  
  
  
  
  
  
style_context: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import importlib
  import importlib.metadata
  import os
  import warnings
  from distutils.util import strtobool
  from functools import lru_cache
  
  import torch
  from packaging import version
  from packaging.version import parse
  
  from .environment import parse_flag_from_env
  from .versions import compare_versions, is_torch_version
  
  
  try:
  						import torch_xla.core.xla_model as xm  # noqa: F401
  
  						_lowerCamelCase							:		int										=						True
  except ImportError:
  						_lowerCamelCase							:		List[str]										=						False
  
  
  # Cache this result has it's a C FFI call which can be pretty time-consuming
  _lowerCamelCase							:		List[Any]										=						torch.distributed.is_available()
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = importlib.util.find_spec(lowercase_						) is not None
  		if package_exists:
  				try:
  						_snake_case			 = importlib.metadata.metadata(lowercase_						)
  						return True
  				except importlib.metadata.PackageNotFoundError:
  						return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _torch_distributed_available
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		try:
  				pass
  		except ImportError:
  				print(
  				    "Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not"
  				    " detected. If you see \"ValueError: Invalid backend: 'ccl'\" error, please install Intel(R) oneCCL"
  				    " Bindings for PyTorch*."						)
  		return (
  		    importlib.util.find_spec("torch_ccl"						) is not None
  		    or importlib.util.find_spec("oneccl_bindings_for_pytorch"						) is not None
  		)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return importlib.metadata.version("oneccl_bind_pt"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("transformer_engine"						)
  
  
  
  
  
  
  @lru_cache
  def 	_lowercase	(			lowercase_=True						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if torch.cuda.is_available():
  				return False
  		if _tpu_available and check_device:
  				try:
  						# Will raise a RuntimeError if no XLA configuration is found
  						_snake_case			 = xm.xla_device()
  						return True
  				except RuntimeError:
  						return False
  		return _tpu_available
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("deepspeed"						)
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if is_tpu_available():
  				return not ignore_tpu
  		if torch.cuda.is_available():
  				return torch.cuda.is_bfaa_supported()
  		if is_npu_available():
  				return False
  		return True
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = _is_package_available("bitsandbytes"						)
  		if package_exists:
  				_snake_case			 = version.parse(importlib.metadata.version("bitsandbytes"						)						)
  				return compare_versions(lowercase_		,							">="		,							"0.39.0"						)
  		return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = _is_package_available("bitsandbytes"						)
  		if package_exists:
  				_snake_case			 = version.parse(importlib.metadata.version("bitsandbytes"						)						)
  				return compare_versions(lowercase_		,							">="		,							"0.37.2"						)
  		return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("bitsandbytes"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"		,							"False"						)						) == 1:
  				_snake_case			 = importlib.util.find_spec("megatron"						) is not None
  				if package_exists:
  						try:
  								_snake_case			 = parse(importlib.metadata.version("megatron-lm"						)						)
  								return compare_versions(lowercase_		,							">="		,							"2.2.0"						)
  						except Exception as e:
  								warnings.warn(f'''Parse Megatron version failed. Exception:{e}'''						)
  								return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("safetensors"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("transformers"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("datasets"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("aim"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("tensorboard"						) or _is_package_available("tensorboardX"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("wandb"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("comet_ml"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("boto3"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if _is_package_available("rich"						):
  				if "ACCELERATE_DISABLE_RICH" in os.environ:
  						warnings.warn(
  						    "`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`."						)
  						return not parse_flag_from_env("ACCELERATE_DISABLE_RICH"		,							lowercase_						)
  				return parse_flag_from_env("ACCELERATE_ENABLE_RICH"		,							lowercase_						)
  		return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("sagemaker"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("tqdm"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("mlflow"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return is_torch_version(">="		,							"1.12"						) and torch.backends.mps.is_available() and torch.backends.mps.is_built()
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		def get_major_and_minor_from_version(lowercase_						):
  				return str(version.parse(lowercase_						).major						) + "." + str(version.parse(lowercase_						).minor						)
  
  		_snake_case			 = importlib.metadata.version("torch"						)
  		if importlib.util.find_spec("intel_extension_for_pytorch"						) is None:
  				return False
  		_snake_case			 = "N/A"
  		try:
  				_snake_case			 = importlib.metadata.version("intel_extension_for_pytorch"						)
  		except importlib.metadata.PackageNotFoundError:
  				return False
  		_snake_case			 = get_major_and_minor_from_version(_torch_version						)
  		_snake_case			 = get_major_and_minor_from_version(_ipex_version						)
  		if torch_major_and_minor != ipex_major_and_minor:
  				warnings.warn(
  				    f'''Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,'''
  				    f''' but PyTorch {_torch_version} is found. Please switch to the matching version and run again.'''						)
  				return False
  		return True
  
  
  
  
  
  
  @lru_cache
  def 	_lowercase	(			lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if importlib.util.find_spec("torch"						) is None or importlib.util.find_spec("torch_npu"						) is None:
  				return False
  
  		import torch
  		import torch_npu  # noqa: F401
  
  		if check_device:
  				try:
  						# Will raise a RuntimeError if no NPU is found
  						_snake_case			 = torch.npu.device_count()
  						return torch.npu.is_available()
  				except RuntimeError:
  						return False
  		return hasattr(lowercase_		,							"npu"						) and torch.npu.is_available()
  
  
  
  
  
  
  @lru_cache
  def 	_lowercase	(			lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if not parse_flag_from_env("ACCELERATE_USE_XPU"		,							default=lowercase_						):
  				return False
  		if is_ipex_available():
  				import torch
  
  				if is_torch_version("<="		,							"1.12"						):
  						return False
  		else:
  				return False
  
  		import intel_extension_for_pytorch  # noqa: F401
  
  		if check_device:
  				try:
  						# Will raise a RuntimeError if no XPU  is found
  						_snake_case			 = torch.xpu.device_count()
  						return torch.xpu.is_available()
  				except RuntimeError:
  						return False
  		return hasattr(lowercase_		,							"xpu"						) and torch.xpu.is_available()
  
  
  
  
  
  