



from typing import Any, Dict, List, Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, ChunkPipeline


if is_vision_available():
	from PIL import Image

	from ..image_utils import load_image

if is_torch_available():
	import torch

	from transformers.modeling_outputs import BaseModelOutput

	from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

A__	      =       logging.get_logger(__name__)





@add_end_docstrings(lowerCamelCase__       )
class 					__lowerCAmelCase (     lowerCamelCase__       ):




				def __init__(							self						,				**_snake_case		):



									"""simple docstring"""





									super().__init__(**_snake_case		)

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

									requires_backends(self						,				"""vision"""		)
									self.check_model_type(_snake_case		)




				def __call__(							self						,				_snake_case						,				_snake_case = None						,				**_snake_case						,				):



									"""simple docstring"""





									if "text_queries" in kwargs:
														_lowerCAmelCase						=    kwargs.pop("""text_queries"""		)

									if isinstance(_snake_case						,				(str, Image.Image)		):
														_lowerCAmelCase						=    {"""image""": image, """candidate_labels""": candidate_labels}
									else:
														_lowerCAmelCase						=    image
									_lowerCAmelCase						=    super().__call__(_snake_case						,				**_snake_case		)
									return results




				def 							snake_case   (							self						,				**_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    {}
									if "threshold" in kwargs:
														_lowerCAmelCase						=    kwargs["""threshold"""]
									if "top_k" in kwargs:
														_lowerCAmelCase						=    kwargs["""top_k"""]
									return {}, {}, postprocess_params




				def 							snake_case   (							self						,				_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    load_image(inputs["""image"""]		)
									_lowerCAmelCase						=    inputs["""candidate_labels"""]
									if isinstance(_snake_case						,				_snake_case		):
														_lowerCAmelCase						=    candidate_labels.split(""","""		)

									_lowerCAmelCase						=    torch.tensor([[image.height, image.width]]						,				dtype=torch.intaa		)
									for i, candidate_label in enumerate(_snake_case		):
														_lowerCAmelCase						=    self.tokenizer(_snake_case						,				return_tensors=self.framework		)
														_lowerCAmelCase						=    self.image_processor(_snake_case						,				return_tensors=self.framework		)
														yield {
														    "is_last": i == len(_snake_case		) - 1,
														    "target_size": target_size,
														    "candidate_label": candidate_label,
														    **text_inputs,
														    **image_features,
														}




				def 							snake_case   (							self						,				_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    model_inputs.pop("""target_size"""		)
									_lowerCAmelCase						=    model_inputs.pop("""candidate_label"""		)
									_lowerCAmelCase						=    model_inputs.pop("""is_last"""		)

									_lowerCAmelCase						=    self.model(**_snake_case		)

									_lowerCAmelCase						=    {"""target_size""": target_size, """candidate_label""": candidate_label, """is_last""": is_last, **outputs}
									return model_outputs




				def 							snake_case   (							self						,				_snake_case						,				_snake_case=0.1						,				_snake_case=None		):



									"""simple docstring"""





									_lowerCAmelCase						=    []
									for model_output in model_outputs:
														_lowerCAmelCase						=    model_output["""candidate_label"""]
														_lowerCAmelCase						=    BaseModelOutput(_snake_case		)
														_lowerCAmelCase						=    self.image_processor.post_process_object_detection(
														    outputs=_snake_case						,				threshold=_snake_case						,				target_sizes=model_output["""target_size"""]		)[0]

														for index in outputs["scores"].nonzero():
																			_lowerCAmelCase						=    outputs["""scores"""][index].item()
																			_lowerCAmelCase						=    self._get_bounding_box(outputs["""boxes"""][index][0]		)

																			_lowerCAmelCase						=    {"""score""": score, """label""": label, """box""": box}
																			results.append(_snake_case		)

									_lowerCAmelCase						=    sorted(_snake_case						,				key=lambda _snake_case		: x["score"]						,				reverse=_snake_case		)
									if top_k:
														_lowerCAmelCase						=    results[:top_k]

									return results




				def 							snake_case   (							self						,				_snake_case		):



									"""simple docstring"""





									if self.framework != "pt":
														raise ValueError("""The ZeroShotObjectDetectionPipeline is only available in PyTorch."""		)
									_lowerCAmelCase	,	_lowerCAmelCase	,	_lowerCAmelCase	,	_lowerCAmelCase						=    box.int().tolist()
									_lowerCAmelCase						=    {
									    """xmin""": xmin,
									    """ymin""": ymin,
									    """xmax""": xmax,
									    """ymax""": ymax,
									}
									return bbox







'''simple docstring'''


from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase_		:   Dict							   =		logging.get_logger(__name__)

UpperCAmelCase_		:   Optional[int]							   =		{
    'google/canine-s': 'https://huggingface.co/google/canine-s/resolve/main/config.json',
    # See all CANINE models at https://huggingface.co/models?filter=canine
}





class     lowercase__  (						_snake_case					):





							'''simple docstring'''


							A_							:      Optional[int]      	=  """canine"""






							def __init__(    self    ,					__snake_case=768    ,					__snake_case=12    ,					__snake_case=12    ,					__snake_case=3072    ,					__snake_case="gelu"    ,					__snake_case=0.1    ,					__snake_case=0.1    ,					__snake_case=1_6384    ,					__snake_case=16    ,					__snake_case=0.02    ,					__snake_case=1e-12    ,					__snake_case=0    ,					__snake_case=0XE000    ,					__snake_case=0XE001    ,					__snake_case=4    ,					__snake_case=4    ,					__snake_case=8    ,					__snake_case=1_6384    ,					__snake_case=128    ,					**__snake_case    ,					):
											super().__init__(pad_token_id=__snake_case    ,					bos_token_id=__snake_case    ,					eos_token_id=__snake_case    ,					**__snake_case  )

											_SCREAMING_SNAKE_CASE :       str     		=      max_position_embeddings
											_SCREAMING_SNAKE_CASE :       Any     		=      hidden_size
											_SCREAMING_SNAKE_CASE :       Dict     		=      num_hidden_layers
											_SCREAMING_SNAKE_CASE :       Tuple     		=      num_attention_heads
											_SCREAMING_SNAKE_CASE :       List[str]     		=      intermediate_size
											_SCREAMING_SNAKE_CASE :       Tuple     		=      hidden_act
											_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      hidden_dropout_prob
											_SCREAMING_SNAKE_CASE :       str     		=      attention_probs_dropout_prob
											_SCREAMING_SNAKE_CASE :       Dict     		=      initializer_range
											_SCREAMING_SNAKE_CASE :       Optional[int]     		=      type_vocab_size
											_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      layer_norm_eps

											# Character config:
											_SCREAMING_SNAKE_CASE :       Any     		=      downsampling_rate
											_SCREAMING_SNAKE_CASE :       List[str]     		=      upsampling_kernel_size
											_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      num_hash_functions
											_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      num_hash_buckets
											_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      local_transformer_stride




