


"""simple docstring"""





from logging import getLogger
from typing import Any, Callable, List, Optional, Union

import numpy as np
import PIL
import torch

from ...schedulers import DDPMScheduler
from ..onnx_utils import ORT_TO_NP_TYPE, OnnxRuntimeModel
from ..pipeline_utils import ImagePipelineOutput
from . import StableDiffusionUpscalePipeline


snake_case__		:  Any     					=					getLogger(__name__)


snake_case__		:  Dict     					=					4
snake_case__		:  Optional[int]     					=					7

snake_case__		:  List[Any]     					=					{
    'float16': torch.floataa,
    'float32': torch.floataa,
}


def   _snake_case    (    _snake_case					:      Tuple      ):
      if isinstance(lowercase__			, torch.Tensor      ):
            return image
      elif isinstance(lowercase__			, PIL.Image.Image      ):
            lowerCAmelCase       :						List[str]							= [image]

      if isinstance(image[0]			, PIL.Image.Image      ):
            lowerCAmelCase       :						Union[str, Any]							= image[0].size
            lowerCAmelCase       :						int							= (x - x % 64 for x in (w, h))  # resize to integer multiple of 32

            lowerCAmelCase       :						Dict							= [np.array(i.resize((w, h)      )      )[None, :] for i in image]
            lowerCAmelCase       :						List[str]							= np.concatenate(lowercase__			, axis=0      )
            lowerCAmelCase       :						Optional[int]							= np.array(lowercase__      ).astype(np.floataa      ) / 255.0
            lowerCAmelCase       :						str							= image.transpose(0			, 3			, 1			, 2      )
            lowerCAmelCase       :						Optional[int]							= 2.0 * image - 1.0
            lowerCAmelCase       :						Tuple							= torch.from_numpy(lowercase__      )
      elif isinstance(image[0]			, torch.Tensor      ):
            lowerCAmelCase       :						List[Any]							= torch.cat(lowercase__			, dim=0      )

      return image






class 		snake_case_(							__UpperCAmelCase      ):






     def __init__(						self	:       Optional[Any]       ,					UpperCamelCase_	:       OnnxRuntimeModel       ,					UpperCamelCase_	:       OnnxRuntimeModel       ,					UpperCamelCase_	:       Any       ,					UpperCamelCase_	:       OnnxRuntimeModel       ,					UpperCamelCase_	:       DDPMScheduler       ,					UpperCamelCase_	:       Any       ,					UpperCamelCase_	:       int = 3_5_0       ,					):
           super().__init__(
               vae=__snake_case       ,					text_encoder=__snake_case       ,					tokenizer=__snake_case       ,					unet=__snake_case       ,					low_res_scheduler=__snake_case       ,					scheduler=__snake_case       ,					safety_checker=__snake_case       ,					feature_extractor=__snake_case       ,					watermarker=__snake_case       ,					max_noise_level=__snake_case       ,					)






     def __call__(						self	:       List[str]       ,					UpperCamelCase_	:       Union[str, List[str]]       ,					UpperCamelCase_	:       Union[torch.FloatTensor, PIL.Image.Image, List[PIL.Image.Image]]       ,					UpperCamelCase_	:       int = 7_5       ,					UpperCamelCase_	:       float = 9.0       ,					UpperCamelCase_	:       int = 2_0       ,					UpperCamelCase_	:       Optional[Union[str, List[str]]] = None       ,					UpperCamelCase_	:       Optional[int] = 1       ,					UpperCamelCase_	:       float = 0.0       ,					UpperCamelCase_	:       Optional[Union[torch.Generator, List[torch.Generator]]] = None       ,					UpperCamelCase_	:       Optional[torch.FloatTensor] = None       ,					UpperCamelCase_	:       Optional[np.ndarray] = None       ,					UpperCamelCase_	:       Optional[np.ndarray] = None       ,					UpperCamelCase_	:       Optional[str] = "pil"       ,					UpperCamelCase_	:       bool = True       ,					UpperCamelCase_	:       Optional[Callable[[int, int, torch.FloatTensor], None]] = None       ,					UpperCamelCase_	:       Optional[int] = 1       ,					):
           self.check_inputs(__snake_case       ,					__snake_case       ,					__snake_case       ,					__snake_case					)

           # 2. Define call parameters
           if prompt is not None and isinstance(__snake_case       ,					__snake_case					):
                 lowerCAmelCase       :						Union[str, Any]							= 1
           elif prompt is not None and isinstance(__snake_case       ,					__snake_case					):
                 lowerCAmelCase       :						Tuple							= len(__snake_case					)
           else:
                 lowerCAmelCase       :						List[Any]							= prompt_embeds.shape[0]

           lowerCAmelCase       :						Any							= self._execution_device
           # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
           # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
           # corresponds to doing no classifier free guidance.
           lowerCAmelCase       :						List[Any]							= guidance_scale > 1.0

           # 3. Encode input prompt
           lowerCAmelCase       :						Dict							= self._encode_prompt(
               __snake_case       ,					__snake_case       ,					__snake_case       ,					__snake_case       ,					__snake_case       ,					prompt_embeds=__snake_case       ,					negative_prompt_embeds=__snake_case       ,					)

           lowerCAmelCase       :						Any							= ORT_TO_PT_TYPE[str(text_embeddings.dtype					)]

           # 4. Preprocess image
           lowerCAmelCase       :						str							= preprocess(__snake_case					)
           lowerCAmelCase       :						Any							= image.cpu()

           # 5. set timesteps
           self.scheduler.set_timesteps(__snake_case       ,					device=__snake_case					)
           lowerCAmelCase       :						Optional[int]							= self.scheduler.timesteps

           # 5. Add noise to image
           lowerCAmelCase       :						Optional[Any]							= torch.tensor([noise_level]       ,					dtype=torch.long       ,					device=__snake_case					)
           lowerCAmelCase       :						Dict							= torch.randn(image.shape       ,					generator=__snake_case       ,					device=__snake_case       ,					dtype=__snake_case					)
           lowerCAmelCase       :						Dict							= self.low_res_scheduler.add_noise(__snake_case       ,					__snake_case       ,					__snake_case					)

           lowerCAmelCase       :						Dict							= 2 if do_classifier_free_guidance else 1
           lowerCAmelCase       :						Dict							= np.concatenate([image] * batch_multiplier * num_images_per_prompt					)
           lowerCAmelCase       :						List[str]							= np.concatenate([noise_level] * image.shape[0]					)

           # 6. Prepare latent variables
           lowerCAmelCase       :						List[Any]							= image.shape[2:]
           lowerCAmelCase       :						Tuple							= self.prepare_latents(
               batch_size * num_images_per_prompt       ,					__snake_case       ,					__snake_case       ,					__snake_case       ,					__snake_case       ,					__snake_case       ,					__snake_case       ,					__snake_case       ,					)

           # 7. Check that sizes of image and latents match
           lowerCAmelCase       :						Tuple							= image.shape[1]
           if NUM_LATENT_CHANNELS + num_channels_image != NUM_UNET_INPUT_CHANNELS:
                 raise ValueError(
                     '''Incorrect configuration settings! The config of `pipeline.unet` expects'''
                     F''' {NUM_UNET_INPUT_CHANNELS} but received `num_channels_latents`: {NUM_LATENT_CHANNELS} +'''
                     F''' `num_channels_image`: {num_channels_image} '''
                     F''' = {NUM_LATENT_CHANNELS+num_channels_image}. Please verify the config of'''
                     ''' `pipeline.unet` or your `image` input.'''					)

           # 8. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
           lowerCAmelCase       :						List[str]							= self.prepare_extra_step_kwargs(__snake_case       ,					__snake_case					)

           lowerCAmelCase       :						Tuple							= next(
               (input.type for input in self.unet.model.get_inputs() if input.name == '''timestep''')       ,					'''tensor(float)'''					)
           lowerCAmelCase       :						Any							= ORT_TO_NP_TYPE[timestep_dtype]

           # 9. Denoising loop
           lowerCAmelCase       :						Optional[Any]							= len(__snake_case					) - num_inference_steps * self.scheduler.order
           with self.progress_bar(total=__snake_case					) as progress_bar:
                 for i, t in enumerate(__snake_case					):
                       # expand the latents if we are doing classifier free guidance
                       lowerCAmelCase       :						Any							= np.concatenate([latents] * 2					) if do_classifier_free_guidance else latents

                       # concat latents, mask, masked_image_latents in the channel dimension
                       lowerCAmelCase       :						int							= self.scheduler.scale_model_input(__snake_case       ,					__snake_case					)
                       lowerCAmelCase       :						str							= np.concatenate([latent_model_input, image]       ,					axis=1					)

                       # timestep to tensor
                       lowerCAmelCase       :						Dict							= np.array([t]       ,					dtype=__snake_case					)

                       # predict the noise residual
                       lowerCAmelCase       :						Tuple							= self.unet(
                           sample=__snake_case       ,					timestep=__snake_case       ,					encoder_hidden_states=__snake_case       ,					class_labels=noise_level.astype(np.intaa					)       ,					)[0]

                       # perform guidance
                       if do_classifier_free_guidance:
                             lowerCAmelCase       :						List[Any]							= np.split(__snake_case       ,					2					)
                       lowerCAmelCase       :						List[str]							= noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

                       # compute the previous noisy sample x_t -> x_t-1
                       lowerCAmelCase       :						Tuple							= self.scheduler.step(
                           torch.from_numpy(__snake_case					)       ,					__snake_case       ,					__snake_case       ,					**__snake_case					).prev_sample

                       # call the callback, if provided
                       if i == len(__snake_case					) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
                             progress_bar.update()
                             if callback is not None and i % callback_steps == 0:
                                   callback(__snake_case       ,					__snake_case       ,					__snake_case					)

        # 10. Post-processing
           lowerCAmelCase       :						int							= self.decode_latents(latents.float()					)

           # 11. Convert to PIL
           if output_type == "pil":
                 lowerCAmelCase       :						Any							= self.numpy_to_pil(__snake_case					)

           if not return_dict:
                 return (image,)

           return ImagePipelineOutput(images=__snake_case					)






     def   lowerCamelCase__  (						self	:       Any       ,					UpperCamelCase_	:       Optional[int]					):
           lowerCAmelCase       :						List[Any]							= 1 / 0.08_333 * latents
           lowerCAmelCase       :						Optional[int]							= self.vae(latent_sample=__snake_case					)[0]
           lowerCAmelCase       :						Union[str, Any]							= np.clip(image / 2 + 0.5       ,					0       ,					1					)
           lowerCAmelCase       :						Union[str, Any]							= image.transpose((0, 2, 3, 1)					)
           return image






     def   lowerCamelCase__  (						self	:       Union[str, Any]       ,					UpperCamelCase_	:       Union[str, List[str]]       ,					UpperCamelCase_	:       Optional[int]       ,					UpperCamelCase_	:       Optional[int]       ,					UpperCamelCase_	:       bool       ,					UpperCamelCase_	:       Optional[str]       ,					UpperCamelCase_	:       Optional[torch.FloatTensor] = None       ,					UpperCamelCase_	:       Optional[torch.FloatTensor] = None       ,					):





           if prompt is not None and isinstance(__snake_case       ,					__snake_case					):
                 lowerCAmelCase       :						int							= 1
           elif prompt is not None and isinstance(__snake_case       ,					__snake_case					):
                 lowerCAmelCase       :						Union[str, Any]							= len(__snake_case					)
           else:
                 lowerCAmelCase       :						Dict							= prompt_embeds.shape[0]

           if prompt_embeds is None:
                 lowerCAmelCase       :						Dict							= self.tokenizer(
                     __snake_case       ,					padding='''max_length'''       ,					max_length=self.tokenizer.model_max_length       ,					truncation=__snake_case       ,					return_tensors='''pt'''       ,					)
                 lowerCAmelCase       :						List[str]							= text_inputs.input_ids
                 lowerCAmelCase       :						List[str]							= self.tokenizer(__snake_case       ,					padding='''longest'''       ,					return_tensors='''pt'''					).input_ids

                 if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
                     __snake_case       ,					__snake_case					):
                       lowerCAmelCase       :						Union[str, Any]							= self.tokenizer.batch_decode(
                           untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]					)
                       logger.warning(
                           '''The following part of your input was truncated because CLIP can only handle sequences up to'''
                           F''' {self.tokenizer.model_max_length} tokens: {removed_text}'''					)

                 # no positional arguments to text_encoder
                 lowerCAmelCase       :						List[str]							= self.text_encoder(
                     input_ids=text_input_ids.int().to(__snake_case					)       ,					)
                 lowerCAmelCase       :						Any							= prompt_embeds[0]

           lowerCAmelCase       :						str							= prompt_embeds.shape
           # duplicate text embeddings for each generation per prompt, using mps friendly method
           lowerCAmelCase       :						Union[str, Any]							= prompt_embeds.repeat(1       ,					__snake_case					)
           lowerCAmelCase       :						List[str]							= prompt_embeds.reshape(bs_embed * num_images_per_prompt       ,					__snake_case       ,					-1					)

           # get unconditional embeddings for classifier free guidance
           if do_classifier_free_guidance and negative_prompt_embeds is None:
                 lowerCAmelCase       :						List[str]
                 if negative_prompt is None:
                       lowerCAmelCase       :						List[str]							= [''] * batch_size
                 elif type(__snake_case					) is not type(__snake_case					):
                       raise TypeError(
                           F'''`negative_prompt` should be the same type to `prompt`, but got {type(__snake_case					)} !='''
                           F''' {type(__snake_case					)}.'''					)
                 elif isinstance(__snake_case       ,					__snake_case					):
                       lowerCAmelCase       :						str							= [negative_prompt]
                 elif batch_size != len(__snake_case					):
                       raise ValueError(
                           F'''`negative_prompt`: {negative_prompt} has batch size {len(__snake_case					)}, but `prompt`:'''
                           F''' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'''
                           ''' the batch size of `prompt`.'''					)
                 else:
                       lowerCAmelCase       :						Tuple							= negative_prompt

                 lowerCAmelCase       :						Tuple							= text_input_ids.shape[-1]
                 lowerCAmelCase       :						Dict							= self.tokenizer(
                     __snake_case       ,					padding='''max_length'''       ,					max_length=__snake_case       ,					truncation=__snake_case       ,					return_tensors='''pt'''       ,					)

                 # if hasattr(uncond_input, "attention_mask"):
                 #     attention_mask = uncond_input.attention_mask.to(device)
                 # else:
                 #     attention_mask = None

                 lowerCAmelCase       :						int							= self.text_encoder(
                     input_ids=uncond_input.input_ids.int().to(__snake_case					)       ,					)
                 lowerCAmelCase       :						List[str]							= uncond_embeddings[0]

           if do_classifier_free_guidance:
                 lowerCAmelCase       :						Dict							= uncond_embeddings.shape[1]
                 # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
                 lowerCAmelCase       :						Optional[int]							= uncond_embeddings.repeat(1       ,					__snake_case					)
                 lowerCAmelCase       :						Dict							= uncond_embeddings.reshape(batch_size * num_images_per_prompt       ,					__snake_case       ,					-1					)

                 # For classifier free guidance, we need to do two forward passes.
                 # Here we concatenate the unconditional and text embeddings into a single batch
                 # to avoid doing two forward passes
                 lowerCAmelCase       :						int							= np.concatenate([uncond_embeddings, prompt_embeds]					)

           return prompt_embeds









'''simple docstring'''






import unittest

from transformers import (
    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    PreTrainedTokenizer,
    is_vision_available,
)
from transformers.pipelines import ImageClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
		from PIL import Image
else:







		class       lowerCamelCase       :


							@staticmethod
							def  SCREAMING_SNAKE_CASE_		(       *__snake_case						:	Optional[Any]							,  **__snake_case						:	str							):





													'''simple docstring'''





													pass







@is_pipeline_test
@require_torch_or_tf
@require_vision
class       lowerCamelCase       (    unittest.TestCase	):
					_SCREAMING_SNAKE_CASE				 =     MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
					_SCREAMING_SNAKE_CASE				 =     TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING


					def  SCREAMING_SNAKE_CASE_		(       self						:	Union[str, Any]							,  __snake_case						:	Any							,  __snake_case						:	Tuple							,  __snake_case						:	Union[str, Any]							):





											'''simple docstring'''





											_snake_case: Union[str, Any]	       =		ImageClassificationPipeline(model=__snake_case							,  image_processor=__snake_case							,  top_k=2							)
											_snake_case: Tuple	       =		[
											    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							),
											    'http://images.cocodataset.org/val2017/000000039769.jpg',
											]
											return image_classifier, examples


					def  SCREAMING_SNAKE_CASE_		(       self						:	Dict							,  __snake_case						:	Any							,  __snake_case						:	str							):





											'''simple docstring'''





											_snake_case: Dict	       =		image_classifier('./tests/fixtures/tests_samples/COCO/000000039769.png'							)

											self.assertEqual(
											    __snake_case							,  [
											        {'score': ANY(__snake_case							), 'label': ANY(__snake_case							)},
											        {'score': ANY(__snake_case							), 'label': ANY(__snake_case							)},
											    ]							,  )

											import datasets

											_snake_case: str	       =		datasets.load_dataset('hf-internal-testing/fixtures_image_utils'							,  'image'							,  split='test'							)

											# Accepts URL + PIL.Image + lists
											_snake_case: List[str]	       =		image_classifier(
											    [
											        Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							),
											        'http://images.cocodataset.org/val2017/000000039769.jpg',
											        # RGBA
											        dataset[0]['file'],
											        # LA
											        dataset[1]['file'],
											        # L
											        dataset[2]['file'],
											    ]							)
											self.assertEqual(
											    __snake_case							,  [
											        [
											            {'score': ANY(__snake_case							), 'label': ANY(__snake_case							)},
											            {'score': ANY(__snake_case							), 'label': ANY(__snake_case							)},
											        ],
											        [
											            {'score': ANY(__snake_case							), 'label': ANY(__snake_case							)},
											            {'score': ANY(__snake_case							), 'label': ANY(__snake_case							)},
											        ],
											        [
											            {'score': ANY(__snake_case							), 'label': ANY(__snake_case							)},
											            {'score': ANY(__snake_case							), 'label': ANY(__snake_case							)},
											        ],
											        [
											            {'score': ANY(__snake_case							), 'label': ANY(__snake_case							)},
											            {'score': ANY(__snake_case							), 'label': ANY(__snake_case							)},
											        ],
											        [
											            {'score': ANY(__snake_case							), 'label': ANY(__snake_case							)},
											            {'score': ANY(__snake_case							), 'label': ANY(__snake_case							)},
											        ],
											    ]							,  )


					@require_torch
					def  SCREAMING_SNAKE_CASE_		(       self						:	Optional[int]							):





											'''simple docstring'''





											_snake_case: Any	       =		'hf-internal-testing/tiny-random-vit'
											_snake_case: List[str]	       =		pipeline('image-classification'							,  model=__snake_case							)

											_snake_case: List[str]	       =		image_classifier('http://images.cocodataset.org/val2017/000000039769.jpg'							)
											self.assertEqual(
											    nested_simplify(__snake_case							,  decimals=4							)							,  [{'label': 'LABEL_1', 'score': 0.574}, {'label': 'LABEL_0', 'score': 0.426}]							,  )

											_snake_case: Dict	       =		image_classifier(
											    [
											        'http://images.cocodataset.org/val2017/000000039769.jpg',
											        'http://images.cocodataset.org/val2017/000000039769.jpg',
											    ]							,  top_k=2							,  )
											self.assertEqual(
											    nested_simplify(__snake_case							,  decimals=4							)							,  [
											        [{'label': 'LABEL_1', 'score': 0.574}, {'label': 'LABEL_0', 'score': 0.426}],
											        [{'label': 'LABEL_1', 'score': 0.574}, {'label': 'LABEL_0', 'score': 0.426}],
											    ]							,  )


					@require_tf
					def  SCREAMING_SNAKE_CASE_		(       self						:	List[str]							):





											'''simple docstring'''





											_snake_case: List[str]	       =		'hf-internal-testing/tiny-random-vit'
											_snake_case: List[str]	       =		pipeline('image-classification'							,  model=__snake_case							,  framework='tf'							)

											_snake_case: Any	       =		image_classifier('http://images.cocodataset.org/val2017/000000039769.jpg'							)
											self.assertEqual(
											    nested_simplify(__snake_case							,  decimals=4							)							,  [{'label': 'LABEL_1', 'score': 0.574}, {'label': 'LABEL_0', 'score': 0.426}]							,  )

											_snake_case: str	       =		image_classifier(
											    [
											        'http://images.cocodataset.org/val2017/000000039769.jpg',
											        'http://images.cocodataset.org/val2017/000000039769.jpg',
											    ]							,  top_k=2							,  )
											self.assertEqual(
											    nested_simplify(__snake_case							,  decimals=4							)							,  [
											        [{'label': 'LABEL_1', 'score': 0.574}, {'label': 'LABEL_0', 'score': 0.426}],
											        [{'label': 'LABEL_1', 'score': 0.574}, {'label': 'LABEL_0', 'score': 0.426}],
											    ]							,  )


					def  SCREAMING_SNAKE_CASE_		(       self						:	Tuple							):





											'''simple docstring'''





											_snake_case: Union[str, Any]	       =		PreTrainedTokenizer()

											# Assert that the pipeline can be initialized with a feature extractor that is not in any mapping
											_snake_case: Any	       =		pipeline(
											    'image-classification'							,  model='hf-internal-testing/tiny-random-vit'							,  tokenizer=__snake_case							)

											self.assertIs(image_classifier.tokenizer							,  __snake_case							)




					@slow
					@require_torch
					def  SCREAMING_SNAKE_CASE_		(       self						:	List[str]							):





											'''simple docstring'''





											_snake_case: Any	       =		pipeline('image-classification'							,  model='deepmind/vision-perceiver-conv'							)
											_snake_case: int	       =		image_classifier('http://images.cocodataset.org/val2017/000000039769.jpg'							)
											self.assertEqual(
											    nested_simplify(__snake_case							,  decimals=4							)							,  [
											        {'score': 0.4_385, 'label': 'tabby, tabby cat'},
											        {'score': 0.321, 'label': 'tiger cat'},
											        {'score': 0.0_502, 'label': 'Egyptian cat'},
											        {'score': 0.0_137, 'label': 'crib, cot'},
											        {'score': 0.007, 'label': 'radiator'},
											    ]							,  )

											_snake_case: Union[str, Any]	       =		pipeline('image-classification'							,  model='deepmind/vision-perceiver-fourier'							)
											_snake_case: int	       =		image_classifier('http://images.cocodataset.org/val2017/000000039769.jpg'							)
											self.assertEqual(
											    nested_simplify(__snake_case							,  decimals=4							)							,  [
											        {'score': 0.5_658, 'label': 'tabby, tabby cat'},
											        {'score': 0.1_309, 'label': 'tiger cat'},
											        {'score': 0.0_722, 'label': 'Egyptian cat'},
											        {'score': 0.0_707, 'label': 'remote control, remote'},
											        {'score': 0.0_082, 'label': 'computer keyboard, keypad'},
											    ]							,  )

											_snake_case: Optional[int]	       =		pipeline('image-classification'							,  model='deepmind/vision-perceiver-learned'							)
											_snake_case: str	       =		image_classifier('http://images.cocodataset.org/val2017/000000039769.jpg'							)
											self.assertEqual(
											    nested_simplify(__snake_case							,  decimals=4							)							,  [
											        {'score': 0.3_022, 'label': 'tabby, tabby cat'},
											        {'score': 0.2_362, 'label': 'Egyptian cat'},
											        {'score': 0.1_856, 'label': 'tiger cat'},
											        {'score': 0.0_324, 'label': 'remote control, remote'},
											        {'score': 0.0_096, 'label': 'quilt, comforter, comfort, puff'},
											    ]							,  )





