code: 
  
  """simple docstring"""
  
  
  
  
  from typing import Dict, List, Optional, Union
  
  import numpy as np
  
  from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
  from ...image_transforms import (
      get_resize_output_image_size,
      normalize,
      pad,
      rescale,
      resize,
      to_channel_dimension_format,
  )
  from ...image_utils import (
      IMAGENET_STANDARD_MEAN,
      IMAGENET_STANDARD_STD,
      ChannelDimension,
      ImageInput,
      PILImageResampling,
      get_image_size,
      make_list_of_images,
      to_numpy_array,
      valid_images,
  )
  from ...utils import TensorType, logging
  from ...utils.import_utils import is_vision_available
  
  
  __A  :					str												= logging.get_logger(__name__)
  
  
  if is_vision_available():
  	import PIL
  
  
  
  
  
  class     __UpperCamelCase				(     _A		):
  		SCREAMING_SNAKE_CASE              =					["pixel_values"]
  
  
  		def __init__(self				:	int  ,  __SCREAMING_SNAKE_CASE				:	bool = True  ,  __SCREAMING_SNAKE_CASE				:	Dict[str, int] = None  ,  __SCREAMING_SNAKE_CASE				:	PILImageResampling = PILImageResampling.BILINEAR  ,  __SCREAMING_SNAKE_CASE				:	bool = True  ,  __SCREAMING_SNAKE_CASE				:	bool = False  ,  __SCREAMING_SNAKE_CASE				:	bool = True  ,  __SCREAMING_SNAKE_CASE				:	bool = True  ,  __SCREAMING_SNAKE_CASE				:	Union[int, float] = 1 / 2_5_5  ,  __SCREAMING_SNAKE_CASE				:	bool = True  ,  __SCREAMING_SNAKE_CASE				:	Optional[Union[float, List[float]]] = None  ,  __SCREAMING_SNAKE_CASE				:	Optional[Union[float, List[float]]] = None  ,  **__SCREAMING_SNAKE_CASE				:	Optional[int]  ,  ):
  							super().__init__(**__SCREAMING_SNAKE_CASE)
  
  							A    =      size if size is not None else {"height": 2_5_6_0, "width": 1_9_2_0}
  							if isinstance(__SCREAMING_SNAKE_CASE  ,  (tuple, list)):
  												# The previous feature extractor size parameter was in (width, height) format
  												A    =      size[::-1]
  							A    =      get_size_dict(__SCREAMING_SNAKE_CASE)
  
  							A    =      do_resize
  							A    =      size
  							A    =      resample
  							A    =      do_thumbnail
  							A    =      do_align_long_axis
  							A    =      do_pad
  							A    =      do_rescale
  							A    =      rescale_factor
  							A    =      do_normalize
  							A    =      image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
  							A    =      image_std if image_std is not None else IMAGENET_STANDARD_STD
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Optional[Any]  ,  __SCREAMING_SNAKE_CASE				:	np.ndarray  ,  __SCREAMING_SNAKE_CASE				:	Dict[str, int]  ,  __SCREAMING_SNAKE_CASE				:	Optional[Union[str, ChannelDimension]] = None):
  							A    ,					A    =      get_image_size(__SCREAMING_SNAKE_CASE)
  							A    ,					A    =      size["height"], size["width"]
  
  							if (output_width < output_height and input_width > input_height) or (
  							    output_width > output_height and input_width < input_height
  							):
  												A    =      np.rotaa(__SCREAMING_SNAKE_CASE  ,  3)
  
  							if data_format is not None:
  												A    =      to_channel_dimension_format(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE)
  
  							return image
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	str  ,  __SCREAMING_SNAKE_CASE				:	np.ndarray  ,  __SCREAMING_SNAKE_CASE				:	Dict[str, int]  ,  __SCREAMING_SNAKE_CASE				:	bool = False  ,  __SCREAMING_SNAKE_CASE				:	Optional[Union[str, ChannelDimension]] = None  ,  ):
  							A    ,					A    =      size["height"], size["width"]
  							A    ,					A    =      get_image_size(__SCREAMING_SNAKE_CASE)
  
  							A    =      output_width - input_width
  							A    =      output_height - input_height
  
  							if random_padding:
  												A    =      np.random.randint(low=0  ,  high=delta_height + 1)
  												A    =      np.random.randint(low=0  ,  high=delta_width + 1)
  							else:
  												A    =      delta_height // 2
  												A    =      delta_width // 2
  
  							A    =      delta_height - pad_top
  							A    =      delta_width - pad_left
  
  							A    =      ((pad_top, pad_bottom), (pad_left, pad_right))
  							return pad(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE  ,  data_format=__SCREAMING_SNAKE_CASE)
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	int  ,  *__SCREAMING_SNAKE_CASE				:	Union[str, Any]  ,  **__SCREAMING_SNAKE_CASE				:	int):
  							logger.info("pad is deprecated and will be removed in version 4.27. Please use pad_image instead.")
  							return self.pad_image(*__SCREAMING_SNAKE_CASE  ,  **__SCREAMING_SNAKE_CASE)
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Any  ,  __SCREAMING_SNAKE_CASE				:	np.ndarray  ,  __SCREAMING_SNAKE_CASE				:	Dict[str, int]  ,  __SCREAMING_SNAKE_CASE				:	PILImageResampling = PILImageResampling.BICUBIC  ,  __SCREAMING_SNAKE_CASE				:	Optional[Union[str, ChannelDimension]] = None  ,  **__SCREAMING_SNAKE_CASE				:	str  ,  ):
  							A    ,					A    =      get_image_size(__SCREAMING_SNAKE_CASE)
  							A    ,					A    =      size["height"], size["width"]
  
  							# We always resize to the smallest of either the input or output size.
  							A    =      min(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE)
  							A    =      min(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE)
  
  							if height == input_height and width == input_width:
  												return image
  
  							if input_height > input_width:
  												A    =      int(input_width * height / input_height)
  							elif input_width > input_height:
  												A    =      int(input_height * width / input_width)
  
  							return resize(
  							    __SCREAMING_SNAKE_CASE  ,  size=(height, width)  ,  resample=__SCREAMING_SNAKE_CASE  ,  reducing_gap=2.0  ,  data_format=__SCREAMING_SNAKE_CASE  ,  **__SCREAMING_SNAKE_CASE)
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	int  ,  __SCREAMING_SNAKE_CASE				:	np.ndarray  ,  __SCREAMING_SNAKE_CASE				:	Dict[str, int]  ,  __SCREAMING_SNAKE_CASE				:	PILImageResampling = PILImageResampling.BICUBIC  ,  __SCREAMING_SNAKE_CASE				:	Optional[Union[str, ChannelDimension]] = None  ,  **__SCREAMING_SNAKE_CASE				:	Any  ,  ):
  							A    =      get_size_dict(__SCREAMING_SNAKE_CASE)
  							A    =      min(size["height"]  ,  size["width"])
  							A    =      get_resize_output_image_size(__SCREAMING_SNAKE_CASE  ,  size=__SCREAMING_SNAKE_CASE  ,  default_to_square=__SCREAMING_SNAKE_CASE)
  							A    =      resize(__SCREAMING_SNAKE_CASE  ,  size=__SCREAMING_SNAKE_CASE  ,  resample=__SCREAMING_SNAKE_CASE  ,  data_format=__SCREAMING_SNAKE_CASE  ,  **__SCREAMING_SNAKE_CASE)
  							return resized_image
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	str  ,  __SCREAMING_SNAKE_CASE				:	np.ndarray  ,  __SCREAMING_SNAKE_CASE				:	Union[int, float]  ,  __SCREAMING_SNAKE_CASE				:	Optional[Union[str, ChannelDimension]] = None  ,  **__SCREAMING_SNAKE_CASE				:	Tuple  ,  ):
  							return rescale(__SCREAMING_SNAKE_CASE  ,  scale=__SCREAMING_SNAKE_CASE  ,  data_format=__SCREAMING_SNAKE_CASE  ,  **__SCREAMING_SNAKE_CASE)
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Any  ,  __SCREAMING_SNAKE_CASE				:	np.ndarray  ,  __SCREAMING_SNAKE_CASE				:	Union[float, List[float]]  ,  __SCREAMING_SNAKE_CASE				:	Union[float, List[float]]  ,  __SCREAMING_SNAKE_CASE				:	Optional[Union[str, ChannelDimension]] = None  ,  **__SCREAMING_SNAKE_CASE				:	Union[str, Any]  ,  ):
  							return normalize(__SCREAMING_SNAKE_CASE  ,  mean=__SCREAMING_SNAKE_CASE  ,  std=__SCREAMING_SNAKE_CASE  ,  data_format=__SCREAMING_SNAKE_CASE  ,  **__SCREAMING_SNAKE_CASE)
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Any  ,  __SCREAMING_SNAKE_CASE				:	ImageInput  ,  __SCREAMING_SNAKE_CASE				:	bool = None  ,  __SCREAMING_SNAKE_CASE				:	Dict[str, int] = None  ,  __SCREAMING_SNAKE_CASE				:	PILImageResampling = None  ,  __SCREAMING_SNAKE_CASE				:	bool = None  ,  __SCREAMING_SNAKE_CASE				:	bool = None  ,  __SCREAMING_SNAKE_CASE				:	bool = None  ,  __SCREAMING_SNAKE_CASE				:	bool = False  ,  __SCREAMING_SNAKE_CASE				:	bool = None  ,  __SCREAMING_SNAKE_CASE				:	float = None  ,  __SCREAMING_SNAKE_CASE				:	bool = None  ,  __SCREAMING_SNAKE_CASE				:	Optional[Union[float, List[float]]] = None  ,  __SCREAMING_SNAKE_CASE				:	Optional[Union[float, List[float]]] = None  ,  __SCREAMING_SNAKE_CASE				:	Optional[Union[str, TensorType]] = None  ,  __SCREAMING_SNAKE_CASE				:	Optional[ChannelDimension] = ChannelDimension.FIRST  ,  **__SCREAMING_SNAKE_CASE				:	Any  ,  ):
  							A    =      do_resize if do_resize is not None else self.do_resize
  							A    =      size if size is not None else self.size
  							if isinstance(__SCREAMING_SNAKE_CASE  ,  (tuple, list)):
  												# Previous feature extractor had size in (width, height) format
  												A    =      size[::-1]
  							A    =      get_size_dict(__SCREAMING_SNAKE_CASE)
  							A    =      resample if resample is not None else self.resample
  							A    =      do_thumbnail if do_thumbnail is not None else self.do_thumbnail
  							A    =      do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
  							A    =      do_pad if do_pad is not None else self.do_pad
  							A    =      do_rescale if do_rescale is not None else self.do_rescale
  							A    =      rescale_factor if rescale_factor is not None else self.rescale_factor
  							A    =      do_normalize if do_normalize is not None else self.do_normalize
  							A    =      image_mean if image_mean is not None else self.image_mean
  							A    =      image_std if image_std is not None else self.image_std
  
  							A    =      make_list_of_images(__SCREAMING_SNAKE_CASE)
  
  							if not valid_images(__SCREAMING_SNAKE_CASE):
  												raise ValueError(
  												    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
  												    "torch.Tensor, tf.Tensor or jax.ndarray.")
  
  							if do_resize and size is None:
  												raise ValueError("Size must be specified if do_resize is True.")
  
  							if do_rescale and rescale_factor is None:
  												raise ValueError("Rescale factor must be specified if do_rescale is True.")
  
  							if do_pad and size is None:
  												raise ValueError("Size must be specified if do_pad is True.")
  
  							if do_normalize and (image_mean is None or image_std is None):
  												raise ValueError("Image mean and std must be specified if do_normalize is True.")
  
  							# All transformations expect numpy arrays.
  							A    =      [to_numpy_array(__SCREAMING_SNAKE_CASE) for image in images]
  
  							if do_align_long_axis:
  												A    =      [self.align_long_axis(__SCREAMING_SNAKE_CASE  ,  size=__SCREAMING_SNAKE_CASE) for image in images]
  
  							if do_resize:
  												A    =      [self.resize(image=__SCREAMING_SNAKE_CASE  ,  size=__SCREAMING_SNAKE_CASE  ,  resample=__SCREAMING_SNAKE_CASE) for image in images]
  
  							if do_thumbnail:
  												A    =      [self.thumbnail(image=__SCREAMING_SNAKE_CASE  ,  size=__SCREAMING_SNAKE_CASE) for image in images]
  
  							if do_pad:
  												A    =      [self.pad_image(image=__SCREAMING_SNAKE_CASE  ,  size=__SCREAMING_SNAKE_CASE  ,  random_padding=__SCREAMING_SNAKE_CASE) for image in images]
  
  							if do_rescale:
  												A    =      [self.rescale(image=__SCREAMING_SNAKE_CASE  ,  scale=__SCREAMING_SNAKE_CASE) for image in images]
  
  							if do_normalize:
  												A    =      [self.normalize(image=__SCREAMING_SNAKE_CASE  ,  mean=__SCREAMING_SNAKE_CASE  ,  std=__SCREAMING_SNAKE_CASE) for image in images]
  
  							A    =      [to_channel_dimension_format(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE) for image in images]
  
  							A    =      {"pixel_values": images}
  							return BatchFeature(data=__SCREAMING_SNAKE_CASE  ,  tensor_type=__SCREAMING_SNAKE_CASE)
  
  
  
  
  
  
style_context: 
  
  """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     __UpperCamelCase				:
  
  
  			@staticmethod
  			def       SCREAMING_SNAKE_CASE__     (*__SCREAMING_SNAKE_CASE				:	Optional[Any]  ,  **__SCREAMING_SNAKE_CASE				:	Any):
  								pass
  
  
  
  
  
  @is_pipeline_test
  @require_torch_or_tf
  @require_vision
  class     __UpperCamelCase				(     unittest.TestCase		):
  		SCREAMING_SNAKE_CASE              =					MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
  		SCREAMING_SNAKE_CASE              =					TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Any  ,  __SCREAMING_SNAKE_CASE				:	List[str]  ,  __SCREAMING_SNAKE_CASE				:	Union[str, Any]  ,  __SCREAMING_SNAKE_CASE				:	Tuple):
  							A    =      ImageClassificationPipeline(model=__SCREAMING_SNAKE_CASE  ,  image_processor=__SCREAMING_SNAKE_CASE  ,  top_k=2)
  							A    =      [
  							    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				:	Any  ,  __SCREAMING_SNAKE_CASE				:	Optional[int]  ,  __SCREAMING_SNAKE_CASE				:	Dict):
  							A    =      image_classifier("./tests/fixtures/tests_samples/COCO/000000039769.png")
  
  							self.assertEqual(
  							    __SCREAMING_SNAKE_CASE  ,  [
  							        {"score": ANY(__SCREAMING_SNAKE_CASE), "label": ANY(__SCREAMING_SNAKE_CASE)},
  							        {"score": ANY(__SCREAMING_SNAKE_CASE), "label": ANY(__SCREAMING_SNAKE_CASE)},
  							    ]  ,  )
  
  							import datasets
  
  							A    =      datasets.load_dataset("hf-internal-testing/fixtures_image_utils"  ,  "image"  ,  split="test")
  
  							# Accepts URL + PIL.Image + lists
  							A    =      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(
  							    __SCREAMING_SNAKE_CASE  ,  [
  							        [
  							            {"score": ANY(__SCREAMING_SNAKE_CASE), "label": ANY(__SCREAMING_SNAKE_CASE)},
  							            {"score": ANY(__SCREAMING_SNAKE_CASE), "label": ANY(__SCREAMING_SNAKE_CASE)},
  							        ],
  							        [
  							            {"score": ANY(__SCREAMING_SNAKE_CASE), "label": ANY(__SCREAMING_SNAKE_CASE)},
  							            {"score": ANY(__SCREAMING_SNAKE_CASE), "label": ANY(__SCREAMING_SNAKE_CASE)},
  							        ],
  							        [
  							            {"score": ANY(__SCREAMING_SNAKE_CASE), "label": ANY(__SCREAMING_SNAKE_CASE)},
  							            {"score": ANY(__SCREAMING_SNAKE_CASE), "label": ANY(__SCREAMING_SNAKE_CASE)},
  							        ],
  							        [
  							            {"score": ANY(__SCREAMING_SNAKE_CASE), "label": ANY(__SCREAMING_SNAKE_CASE)},
  							            {"score": ANY(__SCREAMING_SNAKE_CASE), "label": ANY(__SCREAMING_SNAKE_CASE)},
  							        ],
  							        [
  							            {"score": ANY(__SCREAMING_SNAKE_CASE), "label": ANY(__SCREAMING_SNAKE_CASE)},
  							            {"score": ANY(__SCREAMING_SNAKE_CASE), "label": ANY(__SCREAMING_SNAKE_CASE)},
  							        ],
  							    ]  ,  )
  
  
  		@require_torch
  		def       SCREAMING_SNAKE_CASE__     (self				:	str):
  							A    =      "hf-internal-testing/tiny-random-vit"
  							A    =      pipeline("image-classification"  ,  model=__SCREAMING_SNAKE_CASE)
  
  							A    =      image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg")
  							self.assertEqual(
  							    nested_simplify(__SCREAMING_SNAKE_CASE  ,  decimals=4)  ,  [{"label": "LABEL_1", "score": 0.5_7_4}, {"label": "LABEL_0", "score": 0.4_2_6}]  ,  )
  
  							A    =      image_classifier(
  							    [
  							        "http://images.cocodataset.org/val2017/000000039769.jpg",
  							        "http://images.cocodataset.org/val2017/000000039769.jpg",
  							    ]  ,  top_k=2  ,  )
  							self.assertEqual(
  							    nested_simplify(__SCREAMING_SNAKE_CASE  ,  decimals=4)  ,  [
  							        [{"label": "LABEL_1", "score": 0.5_7_4}, {"label": "LABEL_0", "score": 0.4_2_6}],
  							        [{"label": "LABEL_1", "score": 0.5_7_4}, {"label": "LABEL_0", "score": 0.4_2_6}],
  							    ]  ,  )
  
  
  		@require_tf
  		def       SCREAMING_SNAKE_CASE__     (self				:	List[str]):
  							A    =      "hf-internal-testing/tiny-random-vit"
  							A    =      pipeline("image-classification"  ,  model=__SCREAMING_SNAKE_CASE  ,  framework="tf")
  
  							A    =      image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg")
  							self.assertEqual(
  							    nested_simplify(__SCREAMING_SNAKE_CASE  ,  decimals=4)  ,  [{"label": "LABEL_1", "score": 0.5_7_4}, {"label": "LABEL_0", "score": 0.4_2_6}]  ,  )
  
  							A    =      image_classifier(
  							    [
  							        "http://images.cocodataset.org/val2017/000000039769.jpg",
  							        "http://images.cocodataset.org/val2017/000000039769.jpg",
  							    ]  ,  top_k=2  ,  )
  							self.assertEqual(
  							    nested_simplify(__SCREAMING_SNAKE_CASE  ,  decimals=4)  ,  [
  							        [{"label": "LABEL_1", "score": 0.5_7_4}, {"label": "LABEL_0", "score": 0.4_2_6}],
  							        [{"label": "LABEL_1", "score": 0.5_7_4}, {"label": "LABEL_0", "score": 0.4_2_6}],
  							    ]  ,  )
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Union[str, Any]):
  							A    =      PreTrainedTokenizer()
  
  							# Assert that the pipeline can be initialized with a feature extractor that is not in any mapping
  							A    =      pipeline(
  							    "image-classification"  ,  model="hf-internal-testing/tiny-random-vit"  ,  tokenizer=__SCREAMING_SNAKE_CASE)
  
  							self.assertIs(image_classifier.tokenizer  ,  __SCREAMING_SNAKE_CASE)
  
  
  		@slow
  		@require_torch
  		def       SCREAMING_SNAKE_CASE__     (self				:	List[Any]):
  							# Perceiver is not tested by `run_pipeline_test` properly.
  							# That is because the type of feature_extractor and model preprocessor need to be kept
  							# in sync, which is not the case in the current design
  							A    =      pipeline("image-classification"  ,  model="deepmind/vision-perceiver-conv")
  							A    =      image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg")
  							self.assertEqual(
  							    nested_simplify(__SCREAMING_SNAKE_CASE  ,  decimals=4)  ,  [
  							        {"score": 0.4_3_8_5, "label": "tabby, tabby cat"},
  							        {"score": 0.3_2_1, "label": "tiger cat"},
  							        {"score": 0.0_5_0_2, "label": "Egyptian cat"},
  							        {"score": 0.0_1_3_7, "label": "crib, cot"},
  							        {"score": 0.0_0_7, "label": "radiator"},
  							    ]  ,  )
  
  							A    =      pipeline("image-classification"  ,  model="deepmind/vision-perceiver-fourier")
  							A    =      image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg")
  							self.assertEqual(
  							    nested_simplify(__SCREAMING_SNAKE_CASE  ,  decimals=4)  ,  [
  							        {"score": 0.5_6_5_8, "label": "tabby, tabby cat"},
  							        {"score": 0.1_3_0_9, "label": "tiger cat"},
  							        {"score": 0.0_7_2_2, "label": "Egyptian cat"},
  							        {"score": 0.0_7_0_7, "label": "remote control, remote"},
  							        {"score": 0.0_0_8_2, "label": "computer keyboard, keypad"},
  							    ]  ,  )
  
  							A    =      pipeline("image-classification"  ,  model="deepmind/vision-perceiver-learned")
  							A    =      image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg")
  							self.assertEqual(
  							    nested_simplify(__SCREAMING_SNAKE_CASE  ,  decimals=4)  ,  [
  							        {"score": 0.3_0_2_2, "label": "tabby, tabby cat"},
  							        {"score": 0.2_3_6_2, "label": "Egyptian cat"},
  							        {"score": 0.1_8_5_6, "label": "tiger cat"},
  							        {"score": 0.0_3_2_4, "label": "remote control, remote"},
  							        {"score": 0.0_0_9_6, "label": "quilt, comforter, comfort, puff"},
  							    ]  ,  )
  
  
  
  
  
  