"""simple docstring"""






from copy import deepcopy
from typing import Optional, Union

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import TensorType, is_tf_available, is_torch_available


if is_torch_available():
						import torch

if is_tf_available():
						import tensorflow as tf
class        snake_case (				__UpperCAmelCase       ):




					"""simple docstring"""

					snake_case__       					=				["image_processor"]
					snake_case__       					=				"SamImageProcessor"







					def __init__(       self     :			List[str]					,lowerCamelCase__     :			Union[str, Any]    ):
									super().__init__(lowerCamelCase__    )
									UpperCAmelCase__    =							self.image_processor
									UpperCAmelCase__    =							-10
									UpperCAmelCase__    =							self.image_processor.size['longest_edge']







					def __call__(       self     :			List[Any]					,lowerCamelCase__     :			Union[str, Any]=None					,lowerCamelCase__     :			List[str]=None					,lowerCamelCase__     :			List[Any]=None					,lowerCamelCase__     :			int=None					,lowerCamelCase__     :			Optional[Union[str, TensorType]] = None					,**lowerCamelCase__     :			Dict					,):
									UpperCAmelCase__    =							self.image_processor(
									    lowerCamelCase__					,return_tensors=lowerCamelCase__					,**lowerCamelCase__					,)

									# pop arguments that are not used in the foward but used nevertheless
									UpperCAmelCase__    =							encoding_image_processor['original_sizes']

									if hasattr(lowerCamelCase__					,'numpy'    ):  # Checks if Torch or TF tensor
													UpperCAmelCase__    =							original_sizes.numpy()

									UpperCAmelCase__   ,			UpperCAmelCase__   ,			UpperCAmelCase__    =							self._check_and_preprocess_points(
									    input_points=lowerCamelCase__					,input_labels=lowerCamelCase__					,input_boxes=lowerCamelCase__					,)

									UpperCAmelCase__    =							self._normalize_and_convert(
									    lowerCamelCase__					,lowerCamelCase__					,input_points=lowerCamelCase__					,input_labels=lowerCamelCase__					,input_boxes=lowerCamelCase__					,return_tensors=lowerCamelCase__					,)

									return encoding_image_processor







					def 	__lowerCAmelCase		(       self     :			Optional[int]					,lowerCamelCase__     :			Dict					,lowerCamelCase__     :			Any					,lowerCamelCase__     :			Union[str, Any]=None					,lowerCamelCase__     :			Any=None					,lowerCamelCase__     :			Tuple=None					,lowerCamelCase__     :			List[Any]="pt"					,):
									if input_points is not None:
													if len(lowerCamelCase__    ) != len(lowerCamelCase__    ):
																	UpperCAmelCase__    =							[
																	    self._normalize_coordinates(self.target_size					,lowerCamelCase__					,original_sizes[0]    ) for point in input_points
																	]
													else:
																	UpperCAmelCase__    =							[
																	    self._normalize_coordinates(self.target_size					,lowerCamelCase__					,lowerCamelCase__    )
																	    for point, original_size in zip(lowerCamelCase__					,lowerCamelCase__    )
																	]
													# check that all arrays have the same shape
													if not all(point.shape == input_points[0].shape for point in input_points    ):
																	if input_labels is not None:
																					UpperCAmelCase__   ,			UpperCAmelCase__    =							self._pad_points_and_labels(lowerCamelCase__					,lowerCamelCase__    )

													UpperCAmelCase__    =							np.array(lowerCamelCase__    )

									if input_labels is not None:
													UpperCAmelCase__    =							np.array(lowerCamelCase__    )

									if input_boxes is not None:
													if len(lowerCamelCase__    ) != len(lowerCamelCase__    ):
																	UpperCAmelCase__    =							[
																	    self._normalize_coordinates(self.target_size					,lowerCamelCase__					,original_sizes[0]					,is_bounding_box=lowerCamelCase__    )
																	    for box in input_boxes
																	]
													else:
																	UpperCAmelCase__    =							[
																	    self._normalize_coordinates(self.target_size					,lowerCamelCase__					,lowerCamelCase__					,is_bounding_box=lowerCamelCase__    )
																	    for box, original_size in zip(lowerCamelCase__					,lowerCamelCase__    )
																	]
													UpperCAmelCase__    =							np.array(lowerCamelCase__    )

									if input_boxes is not None:
													if return_tensors == "pt":
																	UpperCAmelCase__    =							torch.from_numpy(lowerCamelCase__    )
																	# boxes batch size of 1 by default
																	UpperCAmelCase__    =							input_boxes.unsqueeze(1    ) if len(input_boxes.shape    ) != 3 else input_boxes
													elif return_tensors == "tf":
																	UpperCAmelCase__    =							tf.convert_to_tensor(lowerCamelCase__    )
																	# boxes batch size of 1 by default
																	UpperCAmelCase__    =							tf.expand_dims(lowerCamelCase__					,1    ) if len(input_boxes.shape    ) != 3 else input_boxes
													encoding_image_processor.update({'input_boxes': input_boxes}    )
									if input_points is not None:
													if return_tensors == "pt":
																	UpperCAmelCase__    =							torch.from_numpy(lowerCamelCase__    )
																	# point batch size of 1 by default
																	UpperCAmelCase__    =							input_points.unsqueeze(1    ) if len(input_points.shape    ) != 4 else input_points
													elif return_tensors == "tf":
																	UpperCAmelCase__    =							tf.convert_to_tensor(lowerCamelCase__    )
																	# point batch size of 1 by default
																	UpperCAmelCase__    =							tf.expand_dims(lowerCamelCase__					,1    ) if len(input_points.shape    ) != 4 else input_points
													encoding_image_processor.update({'input_points': input_points}    )
									if input_labels is not None:
													if return_tensors == "pt":
																	UpperCAmelCase__    =							torch.from_numpy(lowerCamelCase__    )
																	# point batch size of 1 by default
																	UpperCAmelCase__    =							input_labels.unsqueeze(1    ) if len(input_labels.shape    ) != 3 else input_labels
													elif return_tensors == "tf":
																	UpperCAmelCase__    =							tf.convert_to_tensor(lowerCamelCase__    )
																	# point batch size of 1 by default
																	UpperCAmelCase__    =							tf.expand_dims(lowerCamelCase__					,1    ) if len(input_labels.shape    ) != 3 else input_labels
													encoding_image_processor.update({'input_labels': input_labels}    )

									return encoding_image_processor







					def 	__lowerCAmelCase		(       self     :			Optional[int]					,lowerCamelCase__     :			Dict					,lowerCamelCase__     :			int    ):
									UpperCAmelCase__    =							max([point.shape[0] for point in input_points]    )
									UpperCAmelCase__    =							[]
									for i, point in enumerate(lowerCamelCase__    ):
													if point.shape[0] != expected_nb_points:
																	UpperCAmelCase__    =							np.concatenate(
																	    [point, np.zeros((expected_nb_points - point.shape[0], 2)    ) + self.point_pad_value]					,axis=0    )
																	UpperCAmelCase__    =							np.append(input_labels[i]					,[self.point_pad_value]    )
													processed_input_points.append(lowerCamelCase__    )
									UpperCAmelCase__    =							processed_input_points
									return input_points, input_labels







					def 	__lowerCAmelCase		(       self     :			List[Any]					,lowerCamelCase__     :			int					,lowerCamelCase__     :			np.ndarray					,lowerCamelCase__     :			Any					,lowerCamelCase__     :			Optional[Any]=False    ):
									UpperCAmelCase__   ,			UpperCAmelCase__    =							original_size
									UpperCAmelCase__   ,			UpperCAmelCase__    =							self.image_processor._get_preprocess_shape(lowerCamelCase__					,longest_edge=lowerCamelCase__    )
									UpperCAmelCase__    =							deepcopy(lowerCamelCase__    ).astype(lowerCamelCase__    )

									if is_bounding_box:
													UpperCAmelCase__    =							coords.reshape(-1					,2					,2    )

									UpperCAmelCase__    =							coords[..., 0] * (new_w / old_w)
									UpperCAmelCase__    =							coords[..., 1] * (new_h / old_h)

									if is_bounding_box:
													UpperCAmelCase__    =							coords.reshape(-1					,4    )

									return coords







					def 	__lowerCAmelCase		(       self     :			int					,lowerCamelCase__     :			Optional[Any]=None					,lowerCamelCase__     :			Optional[int]=None					,lowerCamelCase__     :			str=None					,):
									if input_points is not None:
													if hasattr(lowerCamelCase__					,'numpy'    ):  # Checks for TF or Torch tensor
																	UpperCAmelCase__    =							input_points.numpy().tolist()

													if not isinstance(lowerCamelCase__					,lowerCamelCase__    ) or not isinstance(input_points[0]					,lowerCamelCase__    ):
																	raise ValueError('Input points must be a list of list of floating points.'    )
													UpperCAmelCase__    =							[np.array(lowerCamelCase__    ) for input_point in input_points]
									else:
													UpperCAmelCase__    =							None

									if input_labels is not None:
													if hasattr(lowerCamelCase__					,'numpy'    ):
																	UpperCAmelCase__    =							input_labels.numpy().tolist()

													if not isinstance(lowerCamelCase__					,lowerCamelCase__    ) or not isinstance(input_labels[0]					,lowerCamelCase__    ):
																	raise ValueError('Input labels must be a list of list integers.'    )
													UpperCAmelCase__    =							[np.array(lowerCamelCase__    ) for label in input_labels]
									else:
													UpperCAmelCase__    =							None

									if input_boxes is not None:
													if hasattr(lowerCamelCase__					,'numpy'    ):
																	UpperCAmelCase__    =							input_boxes.numpy().tolist()

													if (
													    not isinstance(lowerCamelCase__					,lowerCamelCase__    )
													    or not isinstance(input_boxes[0]					,lowerCamelCase__    )
													    or not isinstance(input_boxes[0][0]					,lowerCamelCase__    )
													):
																	raise ValueError('Input boxes must be a list of list of list of floating points.'    )
													UpperCAmelCase__    =							[np.array(lowerCamelCase__    ).astype(np.floataa    ) for box in input_boxes]
									else:
													UpperCAmelCase__    =							None

									return input_points, input_labels, input_boxes







					@property
					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									UpperCAmelCase__    =							self.image_processor.model_input_names
									return list(dict.fromkeys(lowerCamelCase__    )    )







					def 	__lowerCAmelCase		(       self     :			Optional[Any]					,*lowerCamelCase__     :			int					,**lowerCamelCase__     :			Any    ):
									return self.image_processor.post_process_masks(*lowerCamelCase__					,**lowerCamelCase__    )




"""simple docstring"""






from typing import Optional

import numpy as np
import torch
from torch import nn
from transformers import GPTaConfig, GPTaLMHeadModel
from transformers.modeling_utils import ModuleUtilsMixin

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin
class        snake_case (				__UpperCAmelCase   ,					__UpperCAmelCase   ,					__UpperCAmelCase       ):




					"""simple docstring"""

					snake_case__       					=				[R"h\.\d+\.attn\.bias", R"h\.\d+\.attn\.masked_bias"]







					@register_to_config
					def __init__(       self     :			str					,lowerCamelCase__     :			int					,lowerCamelCase__     :			int					,lowerCamelCase__     :			Optional[int] = None					,lowerCamelCase__     :			int = 50_257					,lowerCamelCase__     :			int = 1_024					,lowerCamelCase__     :			int = 768					,lowerCamelCase__     :			int = 12					,lowerCamelCase__     :			int = 12					,lowerCamelCase__     :			Optional[int] = None					,lowerCamelCase__     :			str = "gelu_new"					,lowerCamelCase__     :			float = 0.1					,lowerCamelCase__     :			float = 0.1					,lowerCamelCase__     :			float = 0.1					,lowerCamelCase__     :			float = 1e-5					,lowerCamelCase__     :			float = 0.0_2					,lowerCamelCase__     :			bool = True					,lowerCamelCase__     :			bool = True					,lowerCamelCase__     :			bool = False					,lowerCamelCase__     :			bool = False					,):
									super().__init__()

									UpperCAmelCase__    =							prefix_length

									if prefix_inner_dim != n_embd and prefix_hidden_dim is None:
													raise ValueError(
													    f'''`prefix_hidden_dim` cannot be `None` when `prefix_inner_dim`: {prefix_hidden_dim} and'''
													    f''' `n_embd`: {n_embd} are not equal.'''    )

									UpperCAmelCase__    =							prefix_inner_dim
									UpperCAmelCase__    =							prefix_hidden_dim

									UpperCAmelCase__    =							(
									    nn.Linear(self.prefix_inner_dim					,self.prefix_hidden_dim    )
									    if self.prefix_hidden_dim is not None
									    else nn.Identity()
									)
									UpperCAmelCase__    =							(
									    nn.Linear(self.prefix_hidden_dim					,lowerCamelCase__    ) if self.prefix_hidden_dim is not None else nn.Identity()
									)

									UpperCAmelCase__    =							GPTaConfig(
									    vocab_size=lowerCamelCase__					,n_positions=lowerCamelCase__					,n_embd=lowerCamelCase__					,n_layer=lowerCamelCase__					,n_head=lowerCamelCase__					,n_inner=lowerCamelCase__					,activation_function=lowerCamelCase__					,resid_pdrop=lowerCamelCase__					,embd_pdrop=lowerCamelCase__					,attn_pdrop=lowerCamelCase__					,layer_norm_epsilon=lowerCamelCase__					,initializer_range=lowerCamelCase__					,scale_attn_weights=lowerCamelCase__					,use_cache=lowerCamelCase__					,scale_attn_by_inverse_layer_idx=lowerCamelCase__					,reorder_and_upcast_attn=lowerCamelCase__					,)
									UpperCAmelCase__    =							GPTaLMHeadModel(lowerCamelCase__    )







					def 	__lowerCAmelCase		(       self     :			str					,lowerCamelCase__     :			torch.Tensor					,lowerCamelCase__     :			torch.Tensor					,lowerCamelCase__     :			Optional[torch.Tensor] = None					,lowerCamelCase__     :			Optional[torch.Tensor] = None					,):
									UpperCAmelCase__    =							self.transformer.transformer.wte(lowerCamelCase__    )
									UpperCAmelCase__    =							self.encode_prefix(lowerCamelCase__    )
									UpperCAmelCase__    =							self.decode_prefix(lowerCamelCase__    )
									UpperCAmelCase__    =							torch.cat((prefix_embeds, embedding_text)					,dim=1    )

									if labels is not None:
													UpperCAmelCase__    =							self.get_dummy_token(input_ids.shape[0]					,input_ids.device    )
													UpperCAmelCase__    =							torch.cat((dummy_token, input_ids)					,dim=1    )
									UpperCAmelCase__    =							self.transformer(inputs_embeds=lowerCamelCase__					,labels=lowerCamelCase__					,attention_mask=lowerCamelCase__    )
									if self.prefix_hidden_dim is not None:
													return out, hidden
									else:
													return out







					def 	__lowerCAmelCase		(       self     :			Union[str, Any]					,lowerCamelCase__     :			int					,lowerCamelCase__     :			torch.device    ):
									return torch.zeros(lowerCamelCase__					,self.prefix_length					,dtype=torch.intaa					,device=lowerCamelCase__    )







					def 	__lowerCAmelCase		(       self     :			Tuple					,lowerCamelCase__     :			List[str]    ):
									return self.encode_prefix(lowerCamelCase__    )







					@torch.no_grad()
					def 	__lowerCAmelCase		(       self     :			Optional[Any]					,lowerCamelCase__     :			Union[str, Any]					,lowerCamelCase__     :			Optional[int]					,lowerCamelCase__     :			Optional[int]    ):
									UpperCAmelCase__    =							torch.split(lowerCamelCase__					,1					,dim=0    )
									UpperCAmelCase__    =							[]
									UpperCAmelCase__    =							[]
									for feature in features:
													UpperCAmelCase__    =							self.decode_prefix(feature.to(lowerCamelCase__    )    )  # back to the clip feature
													# Only support beam search for now
													UpperCAmelCase__   ,			UpperCAmelCase__    =							self.generate_beam(
													    input_embeds=lowerCamelCase__					,device=lowerCamelCase__					,eos_token_id=lowerCamelCase__    )
													generated_tokens.append(output_tokens[0]    )
													generated_seq_lengths.append(seq_lengths[0]    )
									UpperCAmelCase__    =							torch.stack(lowerCamelCase__    )
									UpperCAmelCase__    =							torch.stack(lowerCamelCase__    )
									return generated_tokens, generated_seq_lengths







					@torch.no_grad()
					def 	__lowerCAmelCase		(       self     :			Optional[Any]					,lowerCamelCase__     :			str=None					,lowerCamelCase__     :			List[Any]=None					,lowerCamelCase__     :			Tuple=None					,lowerCamelCase__     :			int = 5					,lowerCamelCase__     :			int = 67					,lowerCamelCase__     :			float = 1.0					,lowerCamelCase__     :			Optional[int] = None					,):
									UpperCAmelCase__    =							eos_token_id
									UpperCAmelCase__    =							None
									UpperCAmelCase__    =							None
									UpperCAmelCase__    =							torch.ones(lowerCamelCase__					,device=lowerCamelCase__					,dtype=torch.int    )
									UpperCAmelCase__    =							torch.zeros(lowerCamelCase__					,device=lowerCamelCase__					,dtype=torch.bool    )

									if input_embeds is not None:
													UpperCAmelCase__    =							input_embeds
									else:
													UpperCAmelCase__    =							self.transformer.transformer.wte(lowerCamelCase__    )

									for i in range(lowerCamelCase__    ):
													UpperCAmelCase__    =							self.transformer(inputs_embeds=lowerCamelCase__    )
													UpperCAmelCase__    =							outputs.logits
													UpperCAmelCase__    =							logits[:, -1, :] / (temperature if temperature > 0 else 1.0)
													UpperCAmelCase__    =							logits.softmax(-1    ).log()

													if scores is None:
																	UpperCAmelCase__   ,			UpperCAmelCase__    =							logits.topk(lowerCamelCase__					,-1    )
																	UpperCAmelCase__    =							generated.expand(lowerCamelCase__					,*generated.shape[1:]    )
																	UpperCAmelCase__   ,			UpperCAmelCase__    =							next_tokens.permute(1					,0    ), scores.squeeze(0    )
																	if tokens is None:
																					UpperCAmelCase__    =							next_tokens
																	else:
																					UpperCAmelCase__    =							tokens.expand(lowerCamelCase__					,*tokens.shape[1:]    )
																					UpperCAmelCase__    =							torch.cat((tokens, next_tokens)					,dim=1    )
													else:
																	UpperCAmelCase__    =							-float(np.inf    )
																	UpperCAmelCase__    =							0
																	UpperCAmelCase__    =							scores[:, None] + logits
																	seq_lengths[~is_stopped] += 1
																	UpperCAmelCase__    =							scores_sum / seq_lengths[:, None]
																	UpperCAmelCase__   ,			UpperCAmelCase__    =							scores_sum_average.view(-1    ).topk(lowerCamelCase__					,-1    )
																	UpperCAmelCase__    =							next_tokens // scores_sum.shape[1]
																	UpperCAmelCase__    =							seq_lengths[next_tokens_source]
																	UpperCAmelCase__    =							next_tokens % scores_sum.shape[1]
																	UpperCAmelCase__    =							next_tokens.unsqueeze(1    )
																	UpperCAmelCase__    =							tokens[next_tokens_source]
																	UpperCAmelCase__    =							torch.cat((tokens, next_tokens)					,dim=1    )
																	UpperCAmelCase__    =							generated[next_tokens_source]
																	UpperCAmelCase__    =							scores_sum_average * seq_lengths
																	UpperCAmelCase__    =							is_stopped[next_tokens_source]

													UpperCAmelCase__    =							self.transformer.transformer.wte(next_tokens.squeeze()    ).view(generated.shape[0]					,1					,-1    )
													UpperCAmelCase__    =							torch.cat((generated, next_token_embed)					,dim=1    )
													UpperCAmelCase__    =							is_stopped + next_tokens.eq(lowerCamelCase__    ).squeeze()
													if is_stopped.all():
																	break

									UpperCAmelCase__    =							scores / seq_lengths
									UpperCAmelCase__    =							scores.argsort(descending=lowerCamelCase__    )
									# tokens tensors are already padded to max_seq_length
									UpperCAmelCase__    =							[tokens[i] for i in order]
									UpperCAmelCase__    =							torch.stack(lowerCamelCase__					,dim=0    )
									UpperCAmelCase__    =							torch.tensor([seq_lengths[i] for i in order]					,dtype=seq_lengths.dtype    )
									return output_texts, seq_lengths



