



import uuid
from typing import Any, Dict, List, Optional, Union

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


if is_tf_available():
  import tensorflow as tf

if is_torch_available():
  import torch


a_								=       logging.get_logger(__name__)



class 			__lowerCAmelCase  :




 def __init__(    self						,					__UpperCAmelCase = None						,					__UpperCAmelCase = None						,					__UpperCAmelCase=None						,					__UpperCAmelCase=None					):



    '''simple docstring'''
    if not conversation_id:
       __lowerCamelCase    				=     uuid.uuida()
    if past_user_inputs is None:
       __lowerCamelCase    				=     []
    if generated_responses is None:
       __lowerCamelCase    				=     []

    __lowerCamelCase    				=     conversation_id
    __lowerCamelCase    				=     past_user_inputs
    __lowerCamelCase    				=     generated_responses
    __lowerCamelCase    				=     text




 def __eq__(    self						,					__UpperCAmelCase					):



    '''simple docstring'''
    if not isinstance(__UpperCAmelCase						,					__UpperCAmelCase					):
       return False
    if self.uuid == other.uuid:
       return True
    return (
        self.new_user_input == other.new_user_input
        and self.past_user_inputs == other.past_user_inputs
        and self.generated_responses == other.generated_responses
    )




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase = False					):



    '''simple docstring'''
    if self.new_user_input:
       if overwrite:
          logger.warning(
              F"""User input added while unprocessed input was existing: \"{self.new_user_input}\" was overwritten """
              F"""with: \"{text}\"."""					)
          __lowerCamelCase    				=     text
       else:
          logger.warning(
              F"""User input added while unprocessed input was existing: \"{self.new_user_input}\" new input """
              F"""ignored: \"{text}\". Set `overwrite` to True to overwrite unprocessed user input"""					)
    else:
       __lowerCamelCase    				=     text




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    if self.new_user_input:
       self.past_user_inputs.append(self.new_user_input					)
    __lowerCamelCase    				=     None




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase					):



    '''simple docstring'''
    self.generated_responses.append(__UpperCAmelCase					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    for user_input, generated_response in zip(self.past_user_inputs						,					self.generated_responses					):
       yield True, user_input
       yield False, generated_response
    if self.new_user_input:
       yield True, self.new_user_input




 def __repr__(    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     F"""Conversation id: {self.uuid} \n"""
    for is_user, text in self.iter_texts():
       __lowerCamelCase    				=     '''user''' if is_user else '''bot'''
       output += F"""{name} >> {text} \n"""
    return output



@add_end_docstrings(
    lowerCAmelCase__	,						r"""
        min_length_for_response (`int`, *optional*, defaults to 32):
            The minimum length (in number of tokens) for a response.
        minimum_tokens (`int`, *optional*, defaults to 10):
            The minimum length of tokens to leave for a response.
    """	,						)
class 			__lowerCAmelCase  (						lowerCAmelCase__ ):




 def __init__(    self						,					*__UpperCAmelCase						,					**__UpperCAmelCase					):



    '''simple docstring'''
    super().__init__(*__UpperCAmelCase						,					**__UpperCAmelCase					)
    if self.tokenizer.pad_token_id is None:
       __lowerCamelCase    				=     self.tokenizer.eos_token




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase=None						,					__UpperCAmelCase=None						,					__UpperCAmelCase=None						,					**__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     {}
    __lowerCamelCase    				=     {}
    __lowerCamelCase    				=     {}

    if min_length_for_response is not None:
       __lowerCamelCase    				=     min_length_for_response
    if minimum_tokens is not None:
       __lowerCamelCase    				=     minimum_tokens

    if "max_length" in generate_kwargs:
       __lowerCamelCase    				=     generate_kwargs['''max_length''']
       # self.max_length = generate_kwargs.get("max_length", self.model.config.max_length)
    if clean_up_tokenization_spaces is not None:
       __lowerCamelCase    				=     clean_up_tokenization_spaces

    if generate_kwargs:
       forward_params.update(__UpperCAmelCase					)
    return preprocess_params, forward_params, postprocess_params




 def __call__(    self						,					__UpperCAmelCase						,					__UpperCAmelCase=0						,					**__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     super().__call__(__UpperCAmelCase						,					num_workers=__UpperCAmelCase						,					**__UpperCAmelCase					)
    if isinstance(__UpperCAmelCase						,					__UpperCAmelCase					) and len(__UpperCAmelCase					) == 1:
       return outputs[0]
    return outputs




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase=32					):



    '''simple docstring'''
    if not isinstance(__UpperCAmelCase						,					__UpperCAmelCase					):
       raise ValueError('''ConversationalPipeline, expects Conversation as inputs'''					)
    if conversation.new_user_input is None:
       raise ValueError(
           F"""Conversation with UUID {type(conversation.uuid					)} does not contain new user input to process. """
           '''Add user inputs with the conversation\'s `add_user_input` method'''					)
    if hasattr(self.tokenizer						,					'''_build_conversation_input_ids'''					):
       __lowerCamelCase    				=     self.tokenizer._build_conversation_input_ids(__UpperCAmelCase					)
    else:
       # If the tokenizer cannot handle conversations, we default to only the old version
       __lowerCamelCase    				=     self._legacy_parse_and_tokenize(__UpperCAmelCase					)

    if self.framework == "pt":
       __lowerCamelCase    				=     torch.LongTensor([input_ids]					)
    elif self.framework == "tf":
       __lowerCamelCase    				=     tf.constant([input_ids]					)
    return {"input_ids": input_ids, "conversation": conversation}




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase=10						,					**__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     generate_kwargs.get('''max_length'''						,					self.model.config.max_length					)

    __lowerCamelCase    				=     model_inputs['''input_ids'''].shape[1]
    if max_length - minimum_tokens < n:
       logger.warning(F"""Conversation input is to long ({n}), trimming it to ({max_length} - {minimum_tokens})"""					)
       __lowerCamelCase    				=     max_length - minimum_tokens
       __lowerCamelCase    				=     model_inputs['''input_ids'''][:, -trim:]
       if "attention_mask" in model_inputs:
          __lowerCamelCase    				=     model_inputs['''attention_mask'''][:, -trim:]
    __lowerCamelCase    				=     model_inputs.pop('''conversation'''					)
    __lowerCamelCase    				=     max_length
    __lowerCamelCase    				=     self.model.generate(**__UpperCAmelCase						,					**__UpperCAmelCase					)
    if self.model.config.is_encoder_decoder:
       __lowerCamelCase    				=     1
    else:
       __lowerCamelCase    				=     n
    return {"output_ids": output_ids[:, start_position:], "conversation": conversation}




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase=True					):



    '''simple docstring'''
    __lowerCamelCase    				=     model_outputs['''output_ids''']
    __lowerCamelCase    				=     self.tokenizer.decode(
        output_ids[0]						,					skip_special_tokens=__UpperCAmelCase						,					clean_up_tokenization_spaces=__UpperCAmelCase						,					)
    __lowerCamelCase    				=     model_outputs['''conversation''']
    conversation.mark_processed()
    conversation.append_response(__UpperCAmelCase					)
    return conversation




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.tokenizer.eos_token_id
    __lowerCamelCase    				=     []
    for is_user, text in conversation.iter_texts():
       if eos_token_id is not None:
          input_ids.extend(self.tokenizer.encode(__UpperCAmelCase						,					add_special_tokens=__UpperCAmelCase					) + [eos_token_id]					)
       else:
          input_ids.extend(self.tokenizer.encode(__UpperCAmelCase						,					add_special_tokens=__UpperCAmelCase					)					)

    if len(__UpperCAmelCase					) > self.tokenizer.model_max_length:
       __lowerCamelCase    				=     input_ids[-self.tokenizer.model_max_length :]
    return input_ids











import argparse
import re

import numpy as np
import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    SamConfig,
    SamImageProcessor,
    SamModel,
    SamProcessor,
    SamVisionConfig,
)


a_								=       {
    """iou_prediction_head.layers.0""": """iou_prediction_head.proj_in""",
    """iou_prediction_head.layers.1""": """iou_prediction_head.layers.0""",
    """iou_prediction_head.layers.2""": """iou_prediction_head.proj_out""",
    """mask_decoder.output_upscaling.0""": """mask_decoder.upscale_conv1""",
    """mask_decoder.output_upscaling.1""": """mask_decoder.upscale_layer_norm""",
    """mask_decoder.output_upscaling.3""": """mask_decoder.upscale_conv2""",
    """mask_downscaling.0""": """mask_embed.conv1""",
    """mask_downscaling.1""": """mask_embed.layer_norm1""",
    """mask_downscaling.3""": """mask_embed.conv2""",
    """mask_downscaling.4""": """mask_embed.layer_norm2""",
    """mask_downscaling.6""": """mask_embed.conv3""",
    """point_embeddings""": """point_embed""",
    """pe_layer.positional_encoding_gaussian_matrix""": """shared_embedding.positional_embedding""",
    """image_encoder""": """vision_encoder""",
    """neck.0""": """neck.conv1""",
    """neck.1""": """neck.layer_norm1""",
    """neck.2""": """neck.conv2""",
    """neck.3""": """neck.layer_norm2""",
    """patch_embed.proj""": """patch_embed.projection""",
    """.norm""": """.layer_norm""",
    """blocks""": """layers""",
}





def 		a__      (		_UpperCamelCase      :			Optional[Any]				):
   __lowerCamelCase    				=     {}
   state_dict.pop('''pixel_mean'''			,_UpperCamelCase				)
   state_dict.pop('''pixel_std'''			,_UpperCamelCase				)

   __lowerCamelCase    				=     R'''.*.output_hypernetworks_mlps.(\d+).layers.(\d+).*'''

   for key, value in state_dict.items():
      for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
         if key_to_modify in key:
            __lowerCamelCase    				=     key.replace(_UpperCamelCase			,_UpperCamelCase				)

      if re.match(_UpperCamelCase			,_UpperCamelCase				):
         __lowerCamelCase    				=     int(re.match(_UpperCamelCase			,_UpperCamelCase				).group(2				)				)
         if layer_nb == 0:
            __lowerCamelCase    				=     key.replace('''layers.0'''			,'''proj_in'''				)
         elif layer_nb == 1:
            __lowerCamelCase    				=     key.replace('''layers.1'''			,'''layers.0'''				)
         elif layer_nb == 2:
            __lowerCamelCase    				=     key.replace('''layers.2'''			,'''proj_out'''				)

      __lowerCamelCase    				=     value

   __lowerCamelCase    				=     model_state_dict[
       '''prompt_encoder.shared_embedding.positional_embedding'''
   ]

   return model_state_dict





def 		a__      (		_UpperCamelCase      :			Tuple			,_UpperCamelCase      :			Dict			,_UpperCamelCase      :			Any			,_UpperCamelCase      :			Optional[int]="ybelkada/segment-anything"				):
   __lowerCamelCase    				=     hf_hub_download(_UpperCamelCase			,F"""checkpoints/{model_name}.pth"""				)

   if "sam_vit_b" in model_name:
      __lowerCamelCase    				=     SamConfig()
   elif "sam_vit_l" in model_name:
      __lowerCamelCase    				=     SamVisionConfig(
          hidden_size=10_24			,num_hidden_layers=24			,num_attention_heads=16			,global_attn_indexes=[5, 11, 17, 23]			,)

      __lowerCamelCase    				=     SamConfig(
          vision_config=_UpperCamelCase			,)
   elif "sam_vit_h" in model_name:
      __lowerCamelCase    				=     SamVisionConfig(
          hidden_size=12_80			,num_hidden_layers=32			,num_attention_heads=16			,global_attn_indexes=[7, 15, 23, 31]			,)

      __lowerCamelCase    				=     SamConfig(
          vision_config=_UpperCamelCase			,)

   __lowerCamelCase    				=     torch.load(_UpperCamelCase			,map_location='''cpu'''				)
   __lowerCamelCase    				=     replace_keys(_UpperCamelCase				)

   __lowerCamelCase    				=     SamImageProcessor()

   __lowerCamelCase    				=     SamProcessor(image_processor=_UpperCamelCase				)
   __lowerCamelCase    				=     SamModel(_UpperCamelCase				)

   hf_model.load_state_dict(_UpperCamelCase				)
   __lowerCamelCase    				=     hf_model.to('''cuda'''				)

   __lowerCamelCase    				=     '''https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png'''
   __lowerCamelCase    				=     Image.open(requests.get(_UpperCamelCase			,stream=_UpperCamelCase				).raw				).convert('''RGB'''				)

   __lowerCamelCase    				=     [[[4_00, 6_50]]]
   __lowerCamelCase    				=     [[1]]

   __lowerCamelCase    				=     processor(images=np.array(_UpperCamelCase				)			,return_tensors='''pt'''				).to('''cuda'''				)

   with torch.no_grad():
      __lowerCamelCase    				=     hf_model(**_UpperCamelCase				)
   __lowerCamelCase    				=     output.iou_scores.squeeze()

   if model_name == "sam_vit_h_4b8939":
      assert scores[-1].item() == 0.579_890_251_159_668

      __lowerCamelCase    				=     processor(
          images=np.array(_UpperCamelCase				)			,input_points=_UpperCamelCase			,input_labels=_UpperCamelCase			,return_tensors='''pt'''				).to('''cuda'''				)

      with torch.no_grad():
         __lowerCamelCase    				=     hf_model(**_UpperCamelCase				)
      __lowerCamelCase    				=     output.iou_scores.squeeze()

      assert scores[-1].item() == 0.9_712_603_092_193_604

      __lowerCamelCase    				=     ((75, 2_75, 17_25, 8_50),)

      __lowerCamelCase    				=     processor(images=np.array(_UpperCamelCase				)			,input_boxes=_UpperCamelCase			,return_tensors='''pt'''				).to('''cuda'''				)

      with torch.no_grad():
         __lowerCamelCase    				=     hf_model(**_UpperCamelCase				)
      __lowerCamelCase    				=     output.iou_scores.squeeze()

      assert scores[-1].item() == 0.8_686_015_605_926_514

      # Test with 2 points and 1 image.
      __lowerCamelCase    				=     [[[4_00, 6_50], [8_00, 6_50]]]
      __lowerCamelCase    				=     [[1, 1]]

      __lowerCamelCase    				=     processor(
          images=np.array(_UpperCamelCase				)			,input_points=_UpperCamelCase			,input_labels=_UpperCamelCase			,return_tensors='''pt'''				).to('''cuda'''				)

      with torch.no_grad():
         __lowerCamelCase    				=     hf_model(**_UpperCamelCase				)
      __lowerCamelCase    				=     output.iou_scores.squeeze()

      assert scores[-1].item() == 0.9_936_047_792_434_692


if __name__ == "__main__":
  a_								=       argparse.ArgumentParser()
  a_								=       ["""sam_vit_b_01ec64""", """sam_vit_h_4b8939""", """sam_vit_l_0b3195"""]
  parser.add_argument(
      """--model_name""",
      default="""sam_vit_h_4b8939""",
      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""",
  )
  parser.add_argument(
      """--model_hub_id""",
      default="""ybelkada/segment-anything""",
      choices=choices,
      type=str,
      help="""Path to hf config.json of model to convert""",
  )

  a_								=       parser.parse_args()

  convert_sam_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub, args.model_hub_id)






