




'''simple docstring'''



import argparse

import huggingface_hub
import k_diffusion as K
import torch

from diffusers import UNetaDConditionModel


lowerCamelCase_		       =						"""pcuenq/k-upscaler"""
def  SCREAMING_SNAKE_CASE_ (							__A				: Optional[int]       ,     __A				: str       ,     *, __A				: Union[str, Any]       ,     __A				: Tuple  ) -> Any:
   _SCREAMING_SNAKE_CASE       =      {
       # norm1
       f"""{diffusers_resnet_prefix}.norm1.linear.weight""": checkpoint[f"""{resnet_prefix}.main.0.mapper.weight"""],
       f"""{diffusers_resnet_prefix}.norm1.linear.bias""": checkpoint[f"""{resnet_prefix}.main.0.mapper.bias"""],
       # conv1
       f"""{diffusers_resnet_prefix}.conv1.weight""": checkpoint[f"""{resnet_prefix}.main.2.weight"""],
       f"""{diffusers_resnet_prefix}.conv1.bias""": checkpoint[f"""{resnet_prefix}.main.2.bias"""],
       # norm2
       f"""{diffusers_resnet_prefix}.norm2.linear.weight""": checkpoint[f"""{resnet_prefix}.main.4.mapper.weight"""],
       f"""{diffusers_resnet_prefix}.norm2.linear.bias""": checkpoint[f"""{resnet_prefix}.main.4.mapper.bias"""],
       # conv2
       f"""{diffusers_resnet_prefix}.conv2.weight""": checkpoint[f"""{resnet_prefix}.main.6.weight"""],
       f"""{diffusers_resnet_prefix}.conv2.bias""": checkpoint[f"""{resnet_prefix}.main.6.bias"""],
   }

   if resnet.conv_shortcut is not None:
      rv.update(
          {
              f"""{diffusers_resnet_prefix}.conv_shortcut.weight""": checkpoint[f"""{resnet_prefix}.skip.weight"""],
          }  )

   return rv
def  SCREAMING_SNAKE_CASE_ (							__A				: List[Any]       ,     *, __A				: List[str]       ,     __A				: Dict  ) -> List[str]:
   _SCREAMING_SNAKE_CASE,       _SCREAMING_SNAKE_CASE,       _SCREAMING_SNAKE_CASE       =      checkpoint[f"""{attention_prefix}.qkv_proj.weight"""].chunk(3       ,     dim=0  )
   _SCREAMING_SNAKE_CASE,       _SCREAMING_SNAKE_CASE,       _SCREAMING_SNAKE_CASE       =      checkpoint[f"""{attention_prefix}.qkv_proj.bias"""].chunk(3       ,     dim=0  )
   _SCREAMING_SNAKE_CASE       =      {
       # norm
       f"""{diffusers_attention_prefix}.norm1.linear.weight""": checkpoint[f"""{attention_prefix}.norm_in.mapper.weight"""],
       f"""{diffusers_attention_prefix}.norm1.linear.bias""": checkpoint[f"""{attention_prefix}.norm_in.mapper.bias"""],
       # to_q
       f"""{diffusers_attention_prefix}.attn1.to_q.weight""": weight_q.squeeze(-1  ).squeeze(-1  ),
       f"""{diffusers_attention_prefix}.attn1.to_q.bias""": bias_q,
       # to_k
       f"""{diffusers_attention_prefix}.attn1.to_k.weight""": weight_k.squeeze(-1  ).squeeze(-1  ),
       f"""{diffusers_attention_prefix}.attn1.to_k.bias""": bias_k,
       # to_v
       f"""{diffusers_attention_prefix}.attn1.to_v.weight""": weight_v.squeeze(-1  ).squeeze(-1  ),
       f"""{diffusers_attention_prefix}.attn1.to_v.bias""": bias_v,
       # to_out
       f"""{diffusers_attention_prefix}.attn1.to_out.0.weight""": checkpoint[f"""{attention_prefix}.out_proj.weight"""]
       .squeeze(-1  )
       .squeeze(-1  ),
       f"""{diffusers_attention_prefix}.attn1.to_out.0.bias""": checkpoint[f"""{attention_prefix}.out_proj.bias"""],
   }

   return rv
def  SCREAMING_SNAKE_CASE_ (							__A				: Optional[Any]       ,     *, __A				: Optional[Any]       ,     __A				: Union[str, Any]       ,     __A				: int  ) -> Union[str, Any]:
   _SCREAMING_SNAKE_CASE,       _SCREAMING_SNAKE_CASE       =      checkpoint[f"""{attention_prefix}.kv_proj.weight"""].chunk(2       ,     dim=0  )
   _SCREAMING_SNAKE_CASE,       _SCREAMING_SNAKE_CASE       =      checkpoint[f"""{attention_prefix}.kv_proj.bias"""].chunk(2       ,     dim=0  )

   _SCREAMING_SNAKE_CASE       =      {
       # norm2 (ada groupnorm)
       f"""{diffusers_attention_prefix}.norm{diffusers_attention_index}.linear.weight""": checkpoint[
           f"""{attention_prefix}.norm_dec.mapper.weight"""
       ],
       f"""{diffusers_attention_prefix}.norm{diffusers_attention_index}.linear.bias""": checkpoint[
           f"""{attention_prefix}.norm_dec.mapper.bias"""
       ],
       # layernorm on encoder_hidden_state
       f"""{diffusers_attention_prefix}.attn{diffusers_attention_index}.norm_cross.weight""": checkpoint[
           f"""{attention_prefix}.norm_enc.weight"""
       ],
       f"""{diffusers_attention_prefix}.attn{diffusers_attention_index}.norm_cross.bias""": checkpoint[
           f"""{attention_prefix}.norm_enc.bias"""
       ],
       # to_q
       f"""{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_q.weight""": checkpoint[
           f"""{attention_prefix}.q_proj.weight"""
       ]
       .squeeze(-1  )
       .squeeze(-1  ),
       f"""{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_q.bias""": checkpoint[
           f"""{attention_prefix}.q_proj.bias"""
       ],
       # to_k
       f"""{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_k.weight""": weight_k.squeeze(-1  ).squeeze(-1  ),
       f"""{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_k.bias""": bias_k,
       # to_v
       f"""{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_v.weight""": weight_v.squeeze(-1  ).squeeze(-1  ),
       f"""{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_v.bias""": bias_v,
       # to_out
       f"""{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_out.0.weight""": checkpoint[
           f"""{attention_prefix}.out_proj.weight"""
       ]
       .squeeze(-1  )
       .squeeze(-1  ),
       f"""{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_out.0.bias""": checkpoint[
           f"""{attention_prefix}.out_proj.bias"""
       ],
   }

   return rv
def  SCREAMING_SNAKE_CASE_ (							__A				: Any       ,     __A				: List[Any]       ,     __A				: Any       ,     __A				: str  ) -> Any:
   _SCREAMING_SNAKE_CASE       =      "inner_model.u_net.u_blocks" if block_type == "up" else "inner_model.u_net.d_blocks"
   _SCREAMING_SNAKE_CASE       =      f"""{block_prefix}.{block_idx}"""

   _SCREAMING_SNAKE_CASE       =      {}

   if not hasattr(SCREAMING_SNAKE_CASE_       ,     "attentions"  ):
      _SCREAMING_SNAKE_CASE       =      1  # resnet only
   elif not block.attentions[0].add_self_attention:
      _SCREAMING_SNAKE_CASE       =      2  # resnet -> cross-attention
   else:
      _SCREAMING_SNAKE_CASE       =      3  # resnet -> self-attention -> cross-attention)

   for resnet_idx, resnet in enumerate(block.resnets  ):
      # diffusers_resnet_prefix = f"{diffusers_up_block_prefix}.resnets.{resnet_idx}"
      _SCREAMING_SNAKE_CASE       =      f"""{block_type}_blocks.{block_idx}.resnets.{resnet_idx}"""
      _SCREAMING_SNAKE_CASE       =      n * resnet_idx if block_type == "up" else n * resnet_idx + 1
      _SCREAMING_SNAKE_CASE       =      f"""{block_prefix}.{idx}""" if block_type == "up" else f"""{block_prefix}.{idx}"""

      diffusers_checkpoint.update(
          resnet_to_diffusers_checkpoint(
              SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_       ,     diffusers_resnet_prefix=SCREAMING_SNAKE_CASE_       ,     resnet_prefix=SCREAMING_SNAKE_CASE_  )  )

   if hasattr(SCREAMING_SNAKE_CASE_       ,     "attentions"  ):
      for attention_idx, attention in enumerate(block.attentions  ):
         _SCREAMING_SNAKE_CASE       =      f"""{block_type}_blocks.{block_idx}.attentions.{attention_idx}"""
         _SCREAMING_SNAKE_CASE       =      n * attention_idx + 1 if block_type == "up" else n * attention_idx + 2
         _SCREAMING_SNAKE_CASE       =      f"""{block_prefix}.{idx}"""
         _SCREAMING_SNAKE_CASE       =      f"""{block_prefix}.{idx }"""
         _SCREAMING_SNAKE_CASE       =      1 if not attention.add_self_attention else 2
         _SCREAMING_SNAKE_CASE       =      (
             n * attention_idx + cross_attention_index
             if block_type == "up"
             else n * attention_idx + cross_attention_index + 1
         )
         _SCREAMING_SNAKE_CASE       =      f"""{block_prefix}.{idx }"""

         diffusers_checkpoint.update(
             cross_attn_to_diffusers_checkpoint(
                 SCREAMING_SNAKE_CASE_       ,     diffusers_attention_prefix=SCREAMING_SNAKE_CASE_       ,     diffusers_attention_index=2       ,     attention_prefix=SCREAMING_SNAKE_CASE_       ,     )  )

         if attention.add_self_attention is True:
            diffusers_checkpoint.update(
                self_attn_to_diffusers_checkpoint(
                    SCREAMING_SNAKE_CASE_       ,     diffusers_attention_prefix=SCREAMING_SNAKE_CASE_       ,     attention_prefix=SCREAMING_SNAKE_CASE_       ,     )  )

   return diffusers_checkpoint
def  SCREAMING_SNAKE_CASE_ (							__A				: Dict       ,     __A				: Optional[Any]  ) -> Union[str, Any]:
   _SCREAMING_SNAKE_CASE       =      {}

   # pre-processing
   diffusers_checkpoint.update(
       {
           "conv_in.weight": checkpoint["inner_model.proj_in.weight"],
           "conv_in.bias": checkpoint["inner_model.proj_in.bias"],
       }  )

   # timestep and class embedding
   diffusers_checkpoint.update(
       {
           "time_proj.weight": checkpoint["inner_model.timestep_embed.weight"].squeeze(-1  ),
           "time_embedding.linear_1.weight": checkpoint["inner_model.mapping.0.weight"],
           "time_embedding.linear_1.bias": checkpoint["inner_model.mapping.0.bias"],
           "time_embedding.linear_2.weight": checkpoint["inner_model.mapping.2.weight"],
           "time_embedding.linear_2.bias": checkpoint["inner_model.mapping.2.bias"],
           "time_embedding.cond_proj.weight": checkpoint["inner_model.mapping_cond.weight"],
       }  )

   # down_blocks
   for down_block_idx, down_block in enumerate(model.down_blocks  ):
      diffusers_checkpoint.update(block_to_diffusers_checkpoint(SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_       ,     "down"  )  )

   # up_blocks
   for up_block_idx, up_block in enumerate(model.up_blocks  ):
      diffusers_checkpoint.update(block_to_diffusers_checkpoint(SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_       ,     "up"  )  )

   # post-processing
   diffusers_checkpoint.update(
       {
           "conv_out.weight": checkpoint["inner_model.proj_out.weight"],
           "conv_out.bias": checkpoint["inner_model.proj_out.bias"],
       }  )

   return diffusers_checkpoint
def  SCREAMING_SNAKE_CASE_ (							__A				: Optional[Any]  ) -> Optional[int]:
   _SCREAMING_SNAKE_CASE       =      original_config["input_channels"] + original_config["unet_cond_dim"]
   _SCREAMING_SNAKE_CASE       =      original_config["input_channels"] + (1 if original_config["has_variance"] else 0)

   _SCREAMING_SNAKE_CASE       =      original_config["channels"]

   assert (
       len(set(original_config["depths"]  )  ) == 1
   ), "UNet2DConditionModel currently do not support blocks with different number of layers"
   _SCREAMING_SNAKE_CASE       =      original_config["depths"][0]

   _SCREAMING_SNAKE_CASE       =      original_config["mapping_cond_dim"]
   _SCREAMING_SNAKE_CASE       =      original_config["cross_cond_dim"]

   _SCREAMING_SNAKE_CASE       =      []
   _SCREAMING_SNAKE_CASE       =      []
   for s, c in zip(original_config["self_attn_depths"]       ,     original_config["cross_attn_depths"]  ):
      if s:
         _SCREAMING_SNAKE_CASE       =      "self"
         _SCREAMING_SNAKE_CASE       =      "cross" if c else None
      elif c:
         _SCREAMING_SNAKE_CASE       =      "cross"
         _SCREAMING_SNAKE_CASE       =      None
      else:
         _SCREAMING_SNAKE_CASE       =      None
         _SCREAMING_SNAKE_CASE       =      None
      attna_types.append(SCREAMING_SNAKE_CASE_  )
      attna_types.append(SCREAMING_SNAKE_CASE_  )

   _SCREAMING_SNAKE_CASE       =      UNetaDConditionModel(
       in_channels=SCREAMING_SNAKE_CASE_       ,     out_channels=SCREAMING_SNAKE_CASE_       ,     down_block_types=("KDownBlock2D", "KCrossAttnDownBlock2D", "KCrossAttnDownBlock2D", "KCrossAttnDownBlock2D")       ,     mid_block_type=SCREAMING_SNAKE_CASE_       ,     up_block_types=("KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KUpBlock2D")       ,     block_out_channels=SCREAMING_SNAKE_CASE_       ,     layers_per_block=SCREAMING_SNAKE_CASE_       ,     act_fn="gelu"       ,     norm_num_groups=SCREAMING_SNAKE_CASE_       ,     cross_attention_dim=SCREAMING_SNAKE_CASE_       ,     attention_head_dim=64       ,     time_cond_proj_dim=SCREAMING_SNAKE_CASE_       ,     resnet_time_scale_shift="scale_shift"       ,     time_embedding_type="fourier"       ,     timestep_post_act="gelu"       ,     conv_in_kernel=1       ,     conv_out_kernel=1       ,     )

   return unet
def  SCREAMING_SNAKE_CASE_ (							__A				: int  ) -> int:
   _SCREAMING_SNAKE_CASE       =      torch.device("cuda" if torch.cuda.is_available() else "cpu"  )

   _SCREAMING_SNAKE_CASE       =      huggingface_hub.hf_hub_download(SCREAMING_SNAKE_CASE_       ,     "config_laion_text_cond_latent_upscaler_2.json"  )
   _SCREAMING_SNAKE_CASE       =      huggingface_hub.hf_hub_download(
       SCREAMING_SNAKE_CASE_       ,     "laion_text_cond_latent_upscaler_2_1_00470000_slim.pth"  )
   print(f"""loading original model configuration from {orig_config_path}"""  )
   print(f"""loading original model checkpoint from {orig_weights_path}"""  )

   print("converting to diffusers unet"  )
   _SCREAMING_SNAKE_CASE       =      K.config.load_config(open(SCREAMING_SNAKE_CASE_  )  )["model"]
   _SCREAMING_SNAKE_CASE       =      unet_model_from_original_config(SCREAMING_SNAKE_CASE_  )

   _SCREAMING_SNAKE_CASE       =      torch.load(SCREAMING_SNAKE_CASE_       ,     map_location=SCREAMING_SNAKE_CASE_  )["model_ema"]
   _SCREAMING_SNAKE_CASE       =      unet_to_diffusers_checkpoint(SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_  )

   model.load_state_dict(SCREAMING_SNAKE_CASE_       ,     strict=SCREAMING_SNAKE_CASE_  )
   model.save_pretrained(args.dump_path  )
   print(f"""saving converted unet model in {args.dump_path}"""  )


if __name__ == "__main__":
 lowerCamelCase_		       =						argparse.ArgumentParser()

 parser.add_argument('--dump_path', default=None, type=str, required=True, help='Path to the output model.')
 lowerCamelCase_		       =						parser.parse_args()

 main(args)




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 		__magic_name__ :






      @staticmethod
      def      UpperCAmelCase_							(							*_lowercase						,		**_lowercase     )->			Tuple:
          pass






@is_pipeline_test
@require_torch_or_tf
@require_vision
class 		__magic_name__ (				unittest.TestCase							):
     UpperCamelCase_     :Union[str, Any]									=	MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
     UpperCamelCase_     :Any									=	TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING






     def      UpperCAmelCase_							(							self						,		_lowercase						,		_lowercase						,		_lowercase     )->			List[Any]:
         UpperCamelCase_          =		ImageClassificationPipeline(model=_lowercase						,		image_processor=_lowercase						,		top_k=2     )
         UpperCamelCase_          =		[
             Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"     ),
             "http://images.cocodataset.org/val2017/000000039769.jpg",
         ]
         return image_classifier, examples






     def      UpperCAmelCase_							(							self						,		_lowercase						,		_lowercase     )->			List[str]:
         UpperCamelCase_          =		image_classifier("./tests/fixtures/tests_samples/COCO/000000039769.png"     )

         self.assertEqual(
             _lowercase						,		[
                 {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                 {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
             ]						,		)

         import datasets

         UpperCamelCase_          =		datasets.load_dataset("hf-internal-testing/fixtures_image_utils"						,		"image"						,		split="test"     )

         # Accepts URL + PIL.Image + lists
         UpperCamelCase_          =		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(
             _lowercase						,		[
                 [
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                 ],
                 [
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                 ],
                 [
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                 ],
                 [
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                 ],
                 [
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                 ],
             ]						,		)






     @require_torch
     def      UpperCAmelCase_							(							self     )->			str:
         UpperCamelCase_          =		"hf-internal-testing/tiny-random-vit"
         UpperCamelCase_          =		pipeline("image-classification"						,		model=_lowercase     )

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

         UpperCamelCase_          =		image_classifier(
             [
                 "http://images.cocodataset.org/val2017/000000039769.jpg",
                 "http://images.cocodataset.org/val2017/000000039769.jpg",
             ]						,		top_k=2						,		)
         self.assertEqual(
             nested_simplify(_lowercase						,		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      UpperCAmelCase_							(							self     )->			Tuple:
         UpperCamelCase_          =		"hf-internal-testing/tiny-random-vit"
         UpperCamelCase_          =		pipeline("image-classification"						,		model=_lowercase						,		framework="tf"     )

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

         UpperCamelCase_          =		image_classifier(
             [
                 "http://images.cocodataset.org/val2017/000000039769.jpg",
                 "http://images.cocodataset.org/val2017/000000039769.jpg",
             ]						,		top_k=2						,		)
         self.assertEqual(
             nested_simplify(_lowercase						,		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      UpperCAmelCase_							(							self     )->			Optional[Any]:
         UpperCamelCase_          =		PreTrainedTokenizer()

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

         self.assertIs(image_classifier.tokenizer						,		_lowercase     )






     @slow
     @require_torch
     def      UpperCAmelCase_							(							self     )->			int:
         # 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
         UpperCamelCase_          =		pipeline("image-classification"						,		model="deepmind/vision-perceiver-conv"     )
         UpperCamelCase_          =		image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"     )
         self.assertEqual(
             nested_simplify(_lowercase						,		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"},
             ]						,		)

         UpperCamelCase_          =		pipeline("image-classification"						,		model="deepmind/vision-perceiver-fourier"     )
         UpperCamelCase_          =		image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"     )
         self.assertEqual(
             nested_simplify(_lowercase						,		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"},
             ]						,		)

         UpperCamelCase_          =		pipeline("image-classification"						,		model="deepmind/vision-perceiver-learned"     )
         UpperCamelCase_          =		image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"     )
         self.assertEqual(
             nested_simplify(_lowercase						,		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"},
             ]						,		)
