
import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu



class    _snake_case (						unittest.TestCase				):


 def   lowercase__  (       self):


   '''simple docstring'''




   super().tearDown()
   gc.collect()
   torch.cuda.empty_cache()


 @property
 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: Union[str, Any]     		=   1
   lowercase__	: Optional[int]     		=   3
   lowercase__	: Optional[int]     		=   (32, 32)

   lowercase__	: int     		=   floats_tensor((batch_size, num_channels) + sizes       ,	rng=random.Random(0)).to(SCREAMING_SNAKE_CASE_)
   return image


 @property
 def   lowercase__  (       self):


   '''simple docstring'''




   torch.manual_seed(0)
   lowercase__	: str     		=   UNetaDConditionModel(
       block_out_channels=(32, 64)       ,	layers_per_block=2       ,	sample_size=32       ,	in_channels=4       ,	out_channels=4       ,	down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")       ,	up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")       ,	cross_attention_dim=32       ,	)
   return model


 @property
 def   lowercase__  (       self):


   '''simple docstring'''




   torch.manual_seed(0)
   lowercase__	: Optional[Any]     		=   AutoencoderKL(
       block_out_channels=[32, 64]       ,	in_channels=3       ,	out_channels=3       ,	down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]       ,	up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]       ,	latent_channels=4       ,	)
   return model


 @property
 def   lowercase__  (       self):


   '''simple docstring'''




   torch.manual_seed(0)
   lowercase__	: Dict     		=   CLIPTextConfig(
       bos_token_id=0       ,	eos_token_id=2       ,	hidden_size=32       ,	intermediate_size=37       ,	layer_norm_eps=1E-05       ,	num_attention_heads=4       ,	num_hidden_layers=5       ,	pad_token_id=1       ,	vocab_size=10_00       ,	)
   return CLIPTextModel(SCREAMING_SNAKE_CASE_)


 @property
 def   lowercase__  (       self):


   '''simple docstring'''




   def extract(*SCREAMING_SNAKE_CASE_       ,	**SCREAMING_SNAKE_CASE_):



     class    _snake_case :


      def __init__(       self):


        '''simple docstring'''




        lowercase__	: List[Any]     		=   torch.ones([0])



      def   lowercase__  (       self       ,	SCREAMING_SNAKE_CASE_):


        '''simple docstring'''




        self.pixel_values.to(SCREAMING_SNAKE_CASE_)
        return self

     return Out()

   return extract


 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: List[Any]     		=   """cpu"""  # ensure determinism for the device-dependent torch.Generator
   lowercase__	: str     		=   self.dummy_cond_unet
   lowercase__	: str     		=   DDIMScheduler(
       beta_start=0.0_0_0_8_5       ,	beta_end=0.0_1_2       ,	beta_schedule="""scaled_linear"""       ,	clip_sample=SCREAMING_SNAKE_CASE_       ,	set_alpha_to_one=SCREAMING_SNAKE_CASE_       ,	)

   lowercase__	: Union[str, Any]     		=   self.dummy_vae
   lowercase__	: Tuple     		=   self.dummy_text_encoder
   lowercase__	: Tuple     		=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""")

   # make sure here that pndm scheduler skips prk
   lowercase__	: Any     		=   StableDiffusionPipeline(
       unet=SCREAMING_SNAKE_CASE_       ,	scheduler=SCREAMING_SNAKE_CASE_       ,	vae=SCREAMING_SNAKE_CASE_       ,	text_encoder=SCREAMING_SNAKE_CASE_       ,	tokenizer=SCREAMING_SNAKE_CASE_       ,	safety_checker=SCREAMING_SNAKE_CASE_       ,	feature_extractor=self.dummy_extractor       ,	)
   lowercase__	: Optional[Any]     		=   sd_pipe.to(SCREAMING_SNAKE_CASE_)
   sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_)

   lowercase__	: str     		=   """A painting of a squirrel eating a burger"""

   lowercase__	: int     		=   torch.Generator(device=SCREAMING_SNAKE_CASE_).manual_seed(0)
   lowercase__	: Any     		=   sd_pipe([prompt]       ,	generator=SCREAMING_SNAKE_CASE_       ,	guidance_scale=6.0       ,	num_inference_steps=2       ,	output_type="""np""")
   lowercase__	: Dict     		=   output.images

   lowercase__	: List[str]     		=   torch.Generator(device=SCREAMING_SNAKE_CASE_).manual_seed(0)
   lowercase__	: int     		=   sd_pipe(
       [prompt]       ,	generator=SCREAMING_SNAKE_CASE_       ,	guidance_scale=6.0       ,	num_inference_steps=2       ,	output_type="""np"""       ,	return_dict=SCREAMING_SNAKE_CASE_       ,	)[0]

   lowercase__	: List[str]     		=   image[0, -3:, -3:, -1]
   lowercase__	: List[Any]     		=   image_from_tuple[0, -3:, -3:, -1]

   assert image.shape == (1, 64, 64, 3)
   lowercase__	: Tuple     		=   np.array([0.5_7_5_6, 0.6_1_1_8, 0.5_0_0_5, 0.5_0_4_1, 0.5_4_7_1, 0.4_7_2_6, 0.4_9_7_6, 0.4_8_6_5, 0.4_8_6_4])

   assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
   assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2


 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: Optional[Any]     		=   """cpu"""  # ensure determinism for the device-dependent torch.Generator
   lowercase__	: Tuple     		=   self.dummy_cond_unet
   lowercase__	: Dict     		=   PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE_)
   lowercase__	: Dict     		=   self.dummy_vae
   lowercase__	: Optional[int]     		=   self.dummy_text_encoder
   lowercase__	: List[Any]     		=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""")

   # make sure here that pndm scheduler skips prk
   lowercase__	: Tuple     		=   StableDiffusionPipeline(
       unet=SCREAMING_SNAKE_CASE_       ,	scheduler=SCREAMING_SNAKE_CASE_       ,	vae=SCREAMING_SNAKE_CASE_       ,	text_encoder=SCREAMING_SNAKE_CASE_       ,	tokenizer=SCREAMING_SNAKE_CASE_       ,	safety_checker=SCREAMING_SNAKE_CASE_       ,	feature_extractor=self.dummy_extractor       ,	)
   lowercase__	: List[Any]     		=   sd_pipe.to(SCREAMING_SNAKE_CASE_)
   sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_)

   lowercase__	: List[str]     		=   """A painting of a squirrel eating a burger"""
   lowercase__	: str     		=   torch.Generator(device=SCREAMING_SNAKE_CASE_).manual_seed(0)
   lowercase__	: Dict     		=   sd_pipe([prompt]       ,	generator=SCREAMING_SNAKE_CASE_       ,	guidance_scale=6.0       ,	num_inference_steps=2       ,	output_type="""np""")

   lowercase__	: Any     		=   output.images

   lowercase__	: Union[str, Any]     		=   torch.Generator(device=SCREAMING_SNAKE_CASE_).manual_seed(0)
   lowercase__	: Any     		=   sd_pipe(
       [prompt]       ,	generator=SCREAMING_SNAKE_CASE_       ,	guidance_scale=6.0       ,	num_inference_steps=2       ,	output_type="""np"""       ,	return_dict=SCREAMING_SNAKE_CASE_       ,	)[0]

   lowercase__	: Union[str, Any]     		=   image[0, -3:, -3:, -1]
   lowercase__	: Optional[Any]     		=   image_from_tuple[0, -3:, -3:, -1]

   assert image.shape == (1, 64, 64, 3)
   lowercase__	: int     		=   np.array([0.5_1_2_5, 0.5_7_1_6, 0.4_8_2_8, 0.5_0_6_0, 0.5_6_5_0, 0.4_7_6_8, 0.5_1_8_5, 0.4_8_9_5, 0.4_9_9_3])

   assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
   assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2


 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: Union[str, Any]     		=   StableDiffusionPipeline.from_pretrained(
       """hf-internal-testing/tiny-stable-diffusion-lms-pipe"""       ,	safety_checker=SCREAMING_SNAKE_CASE_)
   assert isinstance(SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_)
   assert isinstance(pipe.scheduler       ,	SCREAMING_SNAKE_CASE_)
   assert pipe.safety_checker is None

   lowercase__	: Dict     		=   pipe("""example prompt"""       ,	num_inference_steps=2).images[0]
   assert image is not None

   # check that there's no error when saving a pipeline with one of the models being None
   with tempfile.TemporaryDirectory() as tmpdirname:
     pipe.save_pretrained(SCREAMING_SNAKE_CASE_)
     lowercase__	: List[Any]     		=   StableDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE_)

   # sanity check that the pipeline still works
   assert pipe.safety_checker is None
   lowercase__	: int     		=   pipe("""example prompt"""       ,	num_inference_steps=2).images[0]
   assert image is not None



 @unittest.skipIf(torch_device != """cuda"""       ,	"""This test requires a GPU""")
 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: Dict     		=   self.dummy_cond_unet
   lowercase__	: List[str]     		=   PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE_)
   lowercase__	: int     		=   self.dummy_vae
   lowercase__	: int     		=   self.dummy_text_encoder
   lowercase__	: Union[str, Any]     		=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""")

   # put models in fp16
   lowercase__	: Optional[Any]     		=   unet.half()
   lowercase__	: List[Any]     		=   vae.half()
   lowercase__	: Any     		=   bert.half()

   # make sure here that pndm scheduler skips prk
   lowercase__	: Dict     		=   StableDiffusionPipeline(
       unet=SCREAMING_SNAKE_CASE_       ,	scheduler=SCREAMING_SNAKE_CASE_       ,	vae=SCREAMING_SNAKE_CASE_       ,	text_encoder=SCREAMING_SNAKE_CASE_       ,	tokenizer=SCREAMING_SNAKE_CASE_       ,	safety_checker=SCREAMING_SNAKE_CASE_       ,	feature_extractor=self.dummy_extractor       ,	)
   lowercase__	: Optional[Any]     		=   sd_pipe.to(SCREAMING_SNAKE_CASE_)
   sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_)

   lowercase__	: Dict     		=   """A painting of a squirrel eating a burger"""
   lowercase__	: List[Any]     		=   sd_pipe([prompt]       ,	num_inference_steps=2       ,	output_type="""np""").images

   assert image.shape == (1, 64, 64, 3)



@nightly
@require_torch_gpu
class    _snake_case (						unittest.TestCase				):


 def   lowercase__  (       self):


   '''simple docstring'''




   super().tearDown()
   gc.collect()
   torch.cuda.empty_cache()


 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: Optional[Any]     		=   StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""       ,	safety_checker=SCREAMING_SNAKE_CASE_)
   lowercase__	: str     		=   LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config)
   lowercase__	: List[Any]     		=   sd_pipe.to(SCREAMING_SNAKE_CASE_)
   sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_)

   lowercase__	: int     		=   (
       """portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle"""
       """ coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with"""
       """ anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and"""
       """ children from bahnhof zoo, detailed """
   )
   lowercase__	: Any     		=   40_03_66_03_46
   lowercase__	: Dict     		=   7

   # without safety guidance (sld_guidance_scale = 0)
   lowercase__	: Optional[Any]     		=   torch.manual_seed(SCREAMING_SNAKE_CASE_)
   lowercase__	: Tuple     		=   sd_pipe(
       [prompt]       ,	generator=SCREAMING_SNAKE_CASE_       ,	guidance_scale=SCREAMING_SNAKE_CASE_       ,	num_inference_steps=50       ,	output_type="""np"""       ,	width=5_12       ,	height=5_12       ,	sld_guidance_scale=0       ,	)

   lowercase__	: str     		=   output.images
   lowercase__	: List[str]     		=   image[0, -3:, -3:, -1]
   lowercase__	: List[str]     		=   [0.2_2_7_8, 0.2_2_3_1, 0.2_2_4_9, 0.2_3_3_3, 0.2_3_0_3, 0.1_8_8_5, 0.2_2_7_3, 0.2_1_4_4, 0.2_1_7_6]

   assert image.shape == (1, 5_12, 5_12, 3)

   assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2

   # without safety guidance (strong configuration)
   lowercase__	: List[str]     		=   torch.manual_seed(SCREAMING_SNAKE_CASE_)
   lowercase__	: Any     		=   sd_pipe(
       [prompt]       ,	generator=SCREAMING_SNAKE_CASE_       ,	guidance_scale=SCREAMING_SNAKE_CASE_       ,	num_inference_steps=50       ,	output_type="""np"""       ,	width=5_12       ,	height=5_12       ,	sld_guidance_scale=20_00       ,	sld_warmup_steps=7       ,	sld_threshold=0.0_2_5       ,	sld_momentum_scale=0.5       ,	sld_mom_beta=0.7       ,	)

   lowercase__	: Dict     		=   output.images
   lowercase__	: List[str]     		=   image[0, -3:, -3:, -1]
   lowercase__	: Union[str, Any]     		=   [0.2_3_8_3, 0.2_2_7_6, 0.2_3_6, 0.2_1_9_2, 0.2_1_8_6, 0.2_0_5_3, 0.1_9_7_1, 0.1_9_0_1, 0.1_7_1_9]

   assert image.shape == (1, 5_12, 5_12, 3)

   assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2


 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: Any     		=   StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""       ,	safety_checker=SCREAMING_SNAKE_CASE_)
   lowercase__	: List[Any]     		=   LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config)
   lowercase__	: Union[str, Any]     		=   sd_pipe.to(SCREAMING_SNAKE_CASE_)
   sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_)

   lowercase__	: List[str]     		=   """padme amidala taking a bath artwork, safe for work, no nudity"""
   lowercase__	: Tuple     		=   27_34_97_17_55
   lowercase__	: List[str]     		=   7

   lowercase__	: Dict     		=   torch.manual_seed(SCREAMING_SNAKE_CASE_)
   lowercase__	: List[str]     		=   sd_pipe(
       [prompt]       ,	generator=SCREAMING_SNAKE_CASE_       ,	guidance_scale=SCREAMING_SNAKE_CASE_       ,	num_inference_steps=50       ,	output_type="""np"""       ,	width=5_12       ,	height=5_12       ,	sld_guidance_scale=0       ,	)

   lowercase__	: Tuple     		=   output.images
   lowercase__	: List[str]     		=   image[0, -3:, -3:, -1]
   lowercase__	: int     		=   [0.3_5_0_2, 0.3_6_2_2, 0.3_3_9_6, 0.3_6_4_2, 0.3_4_7_8, 0.3_3_1_8, 0.3_5, 0.3_3_4_8, 0.3_2_9_7]

   assert image.shape == (1, 5_12, 5_12, 3)

   assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2

   lowercase__	: Optional[int]     		=   torch.manual_seed(SCREAMING_SNAKE_CASE_)
   lowercase__	: Optional[Any]     		=   sd_pipe(
       [prompt]       ,	generator=SCREAMING_SNAKE_CASE_       ,	guidance_scale=SCREAMING_SNAKE_CASE_       ,	num_inference_steps=50       ,	output_type="""np"""       ,	width=5_12       ,	height=5_12       ,	sld_guidance_scale=20_00       ,	sld_warmup_steps=7       ,	sld_threshold=0.0_2_5       ,	sld_momentum_scale=0.5       ,	sld_mom_beta=0.7       ,	)

   lowercase__	: List[str]     		=   output.images
   lowercase__	: int     		=   image[0, -3:, -3:, -1]
   lowercase__	: List[Any]     		=   [0.5_5_3_1, 0.5_2_0_6, 0.4_8_9_5, 0.5_1_5_6, 0.5_1_8_2, 0.4_7_5_1, 0.4_8_0_2, 0.4_8_0_3, 0.4_4_4_3]

   assert image.shape == (1, 5_12, 5_12, 3)

   assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2



 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: Any     		=   StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5""")
   lowercase__	: Optional[int]     		=   sd_pipe.to(SCREAMING_SNAKE_CASE_)
   sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_)

   lowercase__	: Dict     		=   (
       """the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."""
       """ leyendecker"""
   )
   lowercase__	: Any     		=   10_44_35_52_34
   lowercase__	: List[str]     		=   12

   lowercase__	: List[str]     		=   torch.manual_seed(SCREAMING_SNAKE_CASE_)
   lowercase__	: Optional[Any]     		=   sd_pipe(
       [prompt]       ,	generator=SCREAMING_SNAKE_CASE_       ,	guidance_scale=SCREAMING_SNAKE_CASE_       ,	num_inference_steps=50       ,	output_type="""np"""       ,	width=5_12       ,	height=5_12       ,	sld_guidance_scale=0       ,	)

   lowercase__	: Tuple     		=   output.images
   lowercase__	: str     		=   image[0, -3:, -3:, -1]
   lowercase__	: Any     		=   np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

   assert image.shape == (1, 5_12, 5_12, 3)

   assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-7

   lowercase__	: Optional[int]     		=   torch.manual_seed(SCREAMING_SNAKE_CASE_)
   lowercase__	: List[str]     		=   sd_pipe(
       [prompt]       ,	generator=SCREAMING_SNAKE_CASE_       ,	guidance_scale=SCREAMING_SNAKE_CASE_       ,	num_inference_steps=50       ,	output_type="""np"""       ,	width=5_12       ,	height=5_12       ,	sld_guidance_scale=20_00       ,	sld_warmup_steps=7       ,	sld_threshold=0.0_2_5       ,	sld_momentum_scale=0.5       ,	sld_mom_beta=0.7       ,	)

   lowercase__	: Optional[int]     		=   output.images
   lowercase__	: Any     		=   image[0, -3:, -3:, -1]
   lowercase__	: Optional[int]     		=   np.array([0.5_8_1_8, 0.6_2_8_5, 0.6_8_3_5, 0.6_0_1_9, 0.6_2_5, 0.6_7_5_4, 0.6_0_9_6, 0.6_3_3_4, 0.6_5_6_1])
   assert image.shape == (1, 5_12, 5_12, 3)

   assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2








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

lowerCamelCase__     :		Optional[Any]        = logging.get_logger(__name__)



@add_end_docstrings(UpperCAmelCase_				)
class    _snake_case (						UpperCAmelCase_				):


 def __init__(       self       ,	**SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




   super().__init__(**SCREAMING_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(SCREAMING_SNAKE_CASE_)


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


   '''simple docstring'''




   if "text_queries" in kwargs:
     lowercase__	: Any     		=   kwargs.pop("""text_queries""")

   if isinstance(SCREAMING_SNAKE_CASE_       ,	(str, Image.Image)):
     lowercase__	: Optional[Any]     		=   {"""image""": image, """candidate_labels""": candidate_labels}
   else:
     lowercase__	: int     		=   image
   lowercase__	: List[str]     		=   super().__call__(SCREAMING_SNAKE_CASE_       ,	**SCREAMING_SNAKE_CASE_)
   return results


 def   lowercase__  (       self       ,	**SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




   lowercase__	: Tuple     		=   {}
   if "threshold" in kwargs:
     lowercase__	: List[Any]     		=   kwargs["""threshold"""]
   if "top_k" in kwargs:
     lowercase__	: int     		=   kwargs["""top_k"""]
   return {}, {}, postprocess_params


 def   lowercase__  (       self       ,	SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




   lowercase__	: str     		=   load_image(inputs["""image"""])
   lowercase__	: Any     		=   inputs["""candidate_labels"""]
   if isinstance(SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_):
     lowercase__	: List[str]     		=   candidate_labels.split(""",""")

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


 def   lowercase__  (       self       ,	SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




   lowercase__	: str     		=   model_inputs.pop("""target_size""")
   lowercase__	: Optional[int]     		=   model_inputs.pop("""candidate_label""")
   lowercase__	: Dict     		=   model_inputs.pop("""is_last""")

   lowercase__	: Union[str, Any]     		=   self.model(**SCREAMING_SNAKE_CASE_)

   lowercase__	: Union[str, Any]     		=   {"""target_size""": target_size, """candidate_label""": candidate_label, """is_last""": is_last, **outputs}
   return model_outputs


 def   lowercase__  (       self       ,	SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_=0.1       ,	SCREAMING_SNAKE_CASE_=None):


   '''simple docstring'''




   lowercase__	: Union[str, Any]     		=   []
   for model_output in model_outputs:
     lowercase__	: Optional[int]     		=   model_output["""candidate_label"""]
     lowercase__	: Tuple     		=   BaseModelOutput(SCREAMING_SNAKE_CASE_)
     lowercase__	: List[str]     		=   self.image_processor.post_process_object_detection(
         outputs=SCREAMING_SNAKE_CASE_       ,	threshold=SCREAMING_SNAKE_CASE_       ,	target_sizes=model_output["""target_size"""])[0]

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

       lowercase__	: Tuple     		=   {"""score""": score, """label""": label, """box""": box}
       results.append(SCREAMING_SNAKE_CASE_)

   lowercase__	: int     		=   sorted(SCREAMING_SNAKE_CASE_       ,	key=lambda SCREAMING_SNAKE_CASE_: x["score"]       ,	reverse=SCREAMING_SNAKE_CASE_)
   if top_k:
     lowercase__	: Any     		=   results[:top_k]

   return results



 def   lowercase__  (       self       ,	SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




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






