




import argparse

import requests
import torch
from PIL import Image

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

def   A   (   _SCREAMING_SNAKE_CASE					)			->				Any:
       lowerCamelCase     :   str    				=      CLIPSegTextConfig()
       lowerCamelCase     :   Dict    				=      CLIPSegVisionConfig(patch_size=16					)

       lowerCamelCase     :   str    				=      True if "refined" in model_name else False
       lowerCamelCase     :   Tuple    				=      16 if "rd16" in model_name else 64

       lowerCamelCase     :   Dict    				=      CLIPSegConfig.from_text_vision_configs(
           _SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE				,use_complex_transposed_convolution=_SCREAMING_SNAKE_CASE				,reduce_dim=_SCREAMING_SNAKE_CASE				,)
       return config

def   A   (   _SCREAMING_SNAKE_CASE					)			->				int:
       # update prefixes
       if "clip_model" in name:
              lowerCamelCase     :   str    				=      name.replace("clip_model"				,"clip"					)
       if "transformer" in name:
              if "visual" in name:
                     lowerCamelCase     :   List[str]    				=      name.replace("visual.transformer"				,"vision_model"					)
              else:
                     lowerCamelCase     :   Optional[int]    				=      name.replace("transformer"				,"text_model"					)
       if "resblocks" in name:
              lowerCamelCase     :   List[str]    				=      name.replace("resblocks"				,"encoder.layers"					)
       if "ln_1" in name:
              lowerCamelCase     :   Tuple    				=      name.replace("ln_1"				,"layer_norm1"					)
       if "ln_2" in name:
              lowerCamelCase     :   Dict    				=      name.replace("ln_2"				,"layer_norm2"					)
       if "c_fc" in name:
              lowerCamelCase     :   List[str]    				=      name.replace("c_fc"				,"fc1"					)
       if "c_proj" in name:
              lowerCamelCase     :   Union[str, Any]    				=      name.replace("c_proj"				,"fc2"					)
       if "attn" in name and "self" not in name:
              lowerCamelCase     :   List[str]    				=      name.replace("attn"				,"self_attn"					)
       # text encoder
       if "token_embedding" in name:
              lowerCamelCase     :   str    				=      name.replace("token_embedding"				,"text_model.embeddings.token_embedding"					)
       if "positional_embedding" in name and "visual" not in name:
              lowerCamelCase     :   List[Any]    				=      name.replace("positional_embedding"				,"text_model.embeddings.position_embedding.weight"					)
       if "ln_final" in name:
              lowerCamelCase     :   Union[str, Any]    				=      name.replace("ln_final"				,"text_model.final_layer_norm"					)
       # vision encoder
       if "visual.class_embedding" in name:
              lowerCamelCase     :   Tuple    				=      name.replace("visual.class_embedding"				,"vision_model.embeddings.class_embedding"					)
       if "visual.conv1" in name:
              lowerCamelCase     :   Optional[int]    				=      name.replace("visual.conv1"				,"vision_model.embeddings.patch_embedding"					)
       if "visual.positional_embedding" in name:
              lowerCamelCase     :   Tuple    				=      name.replace("visual.positional_embedding"				,"vision_model.embeddings.position_embedding.weight"					)
       if "visual.ln_pre" in name:
              lowerCamelCase     :   str    				=      name.replace("visual.ln_pre"				,"vision_model.pre_layrnorm"					)
       if "visual.ln_post" in name:
              lowerCamelCase     :   Any    				=      name.replace("visual.ln_post"				,"vision_model.post_layernorm"					)
       # projection layers
       if "visual.proj" in name:
              lowerCamelCase     :   Optional[int]    				=      name.replace("visual.proj"				,"visual_projection.weight"					)
       if "text_projection" in name:
              lowerCamelCase     :   List[str]    				=      name.replace("text_projection"				,"text_projection.weight"					)
       # decoder
       if "trans_conv" in name:
              lowerCamelCase     :   Tuple    				=      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:
              lowerCamelCase     :   str    				=      "decoder." + name
       if "blocks" in name:
              lowerCamelCase     :   int    				=      name.replace("blocks"				,"decoder.layers"					)
       if "linear1" in name:
              lowerCamelCase     :   Optional[Any]    				=      name.replace("linear1"				,"mlp.fc1"					)
       if "linear2" in name:
              lowerCamelCase     :   Tuple    				=      name.replace("linear2"				,"mlp.fc2"					)
       if "norm1" in name and "layer_" not in name:
              lowerCamelCase     :   List[str]    				=      name.replace("norm1"				,"layer_norm1"					)
       if "norm2" in name and "layer_" not in name:
              lowerCamelCase     :   Optional[int]    				=      name.replace("norm2"				,"layer_norm2"					)

       return name

def   A   (   _SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE					)			->				Any:
       for key in orig_state_dict.copy().keys():
              lowerCamelCase     :   Dict    				=      orig_state_dict.pop(_SCREAMING_SNAKE_CASE					)

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

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

       return orig_state_dict

def   A   (   )			->				Optional[Any]:
       lowerCamelCase     :   List[str]    				=      "http://images.cocodataset.org/val2017/000000039769.jpg"
       lowerCamelCase     :   Union[str, Any]    				=      Image.open(requests.get(_SCREAMING_SNAKE_CASE				,stream=_SCREAMING_SNAKE_CASE					).raw					)
       return image

def   A   (   _SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE					)			->				str:
       lowerCamelCase     :   Dict    				=      get_clipseg_config(_SCREAMING_SNAKE_CASE					)
       lowerCamelCase     :   Union[str, Any]    				=      CLIPSegForImageSegmentation(_SCREAMING_SNAKE_CASE					)
       model.eval()

       lowerCamelCase     :   int    				=      torch.load(_SCREAMING_SNAKE_CASE				,map_location="cpu"					)

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

    # rename some keys
       lowerCamelCase     :   int    				=      convert_state_dict(_SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE					)
       lowerCamelCase				,   lowerCamelCase     :   Dict    				=      model.load_state_dict(_SCREAMING_SNAKE_CASE				,strict=_SCREAMING_SNAKE_CASE					)

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

       lowerCamelCase     :   Union[str, Any]    				=      ViTImageProcessor(size=352					)
       lowerCamelCase     :   int    				=      CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32"					)
       lowerCamelCase     :   Tuple    				=      CLIPSegProcessor(image_processor=_SCREAMING_SNAKE_CASE				,tokenizer=_SCREAMING_SNAKE_CASE					)

       lowerCamelCase     :   Any    				=      prepare_img()
       lowerCamelCase     :   Tuple    				=      ["a glass", "something to fill", "wood", "a jar"]

       lowerCamelCase     :   int    				=      processor(text=_SCREAMING_SNAKE_CASE				,images=[image] * len(_SCREAMING_SNAKE_CASE					)				,padding="max_length"				,return_tensors="pt"					)

       with torch.no_grad():
              lowerCamelCase     :   Any    				=      model(**_SCREAMING_SNAKE_CASE					)

       # verify values
       lowerCamelCase     :   str    				=      torch.tensor([0.1110, -0.1882, 0.1645]					)
       lowerCamelCase     :   int    				=      torch.tensor([0.2692, -0.7197, -0.1328]					)
       if model_name == "clipseg-rd64-refined":
              lowerCamelCase     :   Tuple    				=      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":
              lowerCamelCase     :   Dict    				=      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":
              lowerCamelCase     :   Optional[Any]    				=      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]				,_SCREAMING_SNAKE_CASE				,atol=1e-3					)
       assert torch.allclose(outputs.conditional_embeddings[0, :3]				,_SCREAMING_SNAKE_CASE				,atol=1e-3					)
       assert torch.allclose(outputs.pooled_output[0, :3]				,_SCREAMING_SNAKE_CASE				,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(_SCREAMING_SNAKE_CASE					)
              processor.save_pretrained(_SCREAMING_SNAKE_CASE					)

       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__":
       SCREAMING_SNAKE_CASE__ :   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.'
       )

       SCREAMING_SNAKE_CASE__ :   str						=     parser.parse_args()
       convert_clipseg_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)












import subprocess
from typing import Union

import numpy as np
import requests

from ..utils import add_end_docstrings, is_torch_available, is_torchaudio_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_torch_available():
       from ..models.auto.modeling_auto import MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING

SCREAMING_SNAKE_CASE__ :   Union[str, Any]						=     logging.get_logger(__name__)

def   A   (   _SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE					)			->				np.array:
       lowerCamelCase     :   Optional[Any]    				=      f'''{sampling_rate}'''
       lowerCamelCase     :   Optional[Any]    				=      "1"
       lowerCamelCase     :   Tuple    				=      "f32le"
       lowerCamelCase     :   Any    				=      [
           "ffmpeg",
           "-i",
           "pipe:0",
           "-ac",
           ac,
           "-ar",
           ar,
           "-f",
           format_for_conversion,
           "-hide_banner",
           "-loglevel",
           "quiet",
           "pipe:1",
       ]

       try:
              lowerCamelCase     :   Optional[int]    				=      subprocess.Popen(_SCREAMING_SNAKE_CASE				,stdin=subprocess.PIPE				,stdout=subprocess.PIPE					)
       except FileNotFoundError:
              raise ValueError("ffmpeg was not found but is required to load audio files from filename"					)
       lowerCamelCase     :   Optional[int]    				=      ffmpeg_process.communicate(_SCREAMING_SNAKE_CASE					)
       lowerCamelCase     :   Union[str, Any]    				=      output_stream[0]

       lowerCamelCase     :   Dict    				=      np.frombuffer(_SCREAMING_SNAKE_CASE				,np.floataa					)
       if audio.shape[0] == 0:
              raise ValueError("Malformed soundfile"					)
       return audio




@add_end_docstrings(lowerCAmelCase__  )
class 	UpperCamelCase__			(lowerCAmelCase__  ):

    '''simple docstring'''



    def __init__(					self  ,						*UpperCamelCase__  ,						**UpperCamelCase__  )  ->   Dict:
           # Default, might be overriden by the model.config.
           lowerCamelCase     :   Union[str, Any]    				=      5
           super().__init__(*UpperCamelCase__  ,						**UpperCamelCase__  )

           if self.framework != "pt":
                  raise ValueError(F'''The {self.__class__} is only available in PyTorch.'''  )

           self.check_model_type(UpperCamelCase__  )







    def __call__(					self  ,						UpperCamelCase__  ,						**UpperCamelCase__  ,						)  ->   Optional[int]:
           return super().__call__(UpperCamelCase__  ,						**UpperCamelCase__  )







    def 					_lowercase  (					self  ,						UpperCamelCase__=None  ,						**UpperCamelCase__  )  ->   str:
           # No parameters on this pipeline right now
           lowerCamelCase     :   int    				=      {}
           if top_k is not None:
                  if top_k > self.model.config.num_labels:
                         lowerCamelCase     :   Any    				=      self.model.config.num_labels
                  lowerCamelCase     :   Any    				=      top_k
           return {}, {}, postprocess_params







    def 					_lowercase  (					self  ,						UpperCamelCase__  )  ->   Dict:
           if isinstance(UpperCamelCase__  ,						UpperCamelCase__  ):
                  if inputs.startswith("http://"  ) or inputs.startswith("https://"  ):
                         # We need to actually check for a real protocol, otherwise it's impossible to use a local file
                         # like http_huggingface_co.png
                         lowerCamelCase     :   str    				=      requests.get(UpperCamelCase__  ).content
                  else:
                         with open(UpperCamelCase__  ,						"rb"  ) as f:
                                lowerCamelCase     :   int    				=      f.read()

           if isinstance(UpperCamelCase__  ,						UpperCamelCase__  ):
                  lowerCamelCase     :   str    				=      ffmpeg_read(UpperCamelCase__  ,						self.feature_extractor.sampling_rate  )

           if isinstance(UpperCamelCase__  ,						UpperCamelCase__  ):
                  # Accepting `"array"` which is the key defined in `datasets` for
                  # better integration
                  if not ("sampling_rate" in inputs and ("raw" in inputs or "array" in inputs)):
                         raise ValueError(
                             "When passing a dictionary to AudioClassificationPipeline, the dict needs to contain a "
                             "\"raw\" key containing the numpy array representing the audio and a \"sampling_rate\" key, "
                             "containing the sampling_rate associated with that array"  )

                  lowerCamelCase     :   Optional[int]    				=      inputs.pop("raw"  ,						UpperCamelCase__  )
                  if _inputs is None:
                         # Remove path which will not be used from `datasets`.
                         inputs.pop("path"  ,						UpperCamelCase__  )
                         lowerCamelCase     :   List[str]    				=      inputs.pop("array"  ,						UpperCamelCase__  )
                  lowerCamelCase     :   str    				=      inputs.pop("sampling_rate"  )
                  lowerCamelCase     :   Union[str, Any]    				=      _inputs
                  if in_sampling_rate != self.feature_extractor.sampling_rate:
                         import torch

                         if is_torchaudio_available():
                                from torchaudio import functional as F
                         else:
                                raise ImportError(
                                    "torchaudio is required to resample audio samples in AudioClassificationPipeline. "
                                    "The torchaudio package can be installed through: `pip install torchaudio`."  )

                         lowerCamelCase     :   Tuple    				=      F.resample(
                             torch.from_numpy(UpperCamelCase__  )  ,						UpperCamelCase__  ,						self.feature_extractor.sampling_rate  ).numpy()

           if not isinstance(UpperCamelCase__  ,						np.ndarray  ):
                  raise ValueError("We expect a numpy ndarray as input"  )
           if len(inputs.shape  ) != 1:
                  raise ValueError("We expect a single channel audio input for AudioClassificationPipeline"  )

           lowerCamelCase     :   Optional[int]    				=      self.feature_extractor(
               UpperCamelCase__  ,						sampling_rate=self.feature_extractor.sampling_rate  ,						return_tensors="pt"  )
           return processed







    def 					_lowercase  (					self  ,						UpperCamelCase__  )  ->   str:
           lowerCamelCase     :   Optional[Any]    				=      self.model(**UpperCamelCase__  )
           return model_outputs







    def 					_lowercase  (					self  ,						UpperCamelCase__  ,						UpperCamelCase__=5  )  ->   Tuple:
           lowerCamelCase     :   Tuple    				=      model_outputs.logits[0].softmax(-1  )
           lowerCamelCase				,   lowerCamelCase     :   str    				=      probs.topk(UpperCamelCase__  )

           lowerCamelCase     :   str    				=      scores.tolist()
           lowerCamelCase     :   Optional[int]    				=      ids.tolist()

           lowerCamelCase     :   Optional[int]    				=      [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(UpperCamelCase__  ,						UpperCamelCase__  )]

           return labels






