code: 
  
  """simple docstring"""
  
  
  
  
  import gc
  import os
  import tempfile
  import unittest
  
  import torch
  import torch.nn as nn
  import torch.nn.functional as F
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
  from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
  from diffusers.models.attention_processor import (
      Attention,
      AttnProcessor,
      AttnProcessor2_0,
      LoRAAttnProcessor,
      LoRAAttnProcessor2_0,
      LoRAXFormersAttnProcessor,
      XFormersAttnProcessor,
  )
  from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device
  def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  					A    =      {}
  					for name in unet.attn_processors.keys():
  										A    =      None if name.endswith("attn1.processor"   ) else unet.config.cross_attention_dim
  										if name.startswith("mid_block"   ):
  															A    =      unet.config.block_out_channels[-1]
  										elif name.startswith("up_blocks"   ):
  															A    =      int(name[len("up_blocks."   )]   )
  															A    =      list(reversed(unet.config.block_out_channels   )   )[block_id]
  										elif name.startswith("down_blocks"   ):
  															A    =      int(name[len("down_blocks."   )]   )
  															A    =      unet.config.block_out_channels[block_id]
  										A    =      (
  										    LoRAAttnProcessor2_0 if hasattr(lowercase__    ,							"scaled_dot_product_attention"   ) else LoRAAttnProcessor
  										)
  										A    =      lora_attn_processor_class(
  										    hidden_size=lowercase__    ,							cross_attention_dim=lowercase__   )
  					A    =      AttnProcsLayers(lowercase__   )
  					return lora_attn_procs, unet_lora_layers
  def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  					A    =      {}
  					A    =      (
  					    LoRAAttnProcessor2_0 if hasattr(lowercase__    ,							"scaled_dot_product_attention"   ) else LoRAAttnProcessor
  					)
  					for name, module in text_encoder.named_modules():
  										if name.endswith(lowercase__   ):
  															A    =      lora_attn_processor_class(
  															    hidden_size=module.out_proj.out_features    ,							cross_attention_dim=lowercase__   )
  					return text_lora_attn_procs
  def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  					A    =      create_text_encoder_lora_attn_procs(lowercase__   )
  					A    =      AttnProcsLayers(lowercase__   )
  					return text_encoder_lora_layers
  def      __SCREAMING_SNAKE_CASE		(		lowercase__    ,							lowercase__=False   ):
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for _, attn_proc in text_lora_attn_procs.items():
  										# set up.weights
  										for layer_name, layer_module in attn_proc.named_modules():
  															if layer_name.endswith("_lora"   ):
  																				A    =      (
  																				    torch.randn_like(layer_module.up.weight   )
  																				    if randn_weight
  																				    else torch.zeros_like(layer_module.up.weight   )
  																				)
  																				A    =      torch.nn.Parameter(lowercase__   )
  
  
  
  
  
  class     __UpperCamelCase				(     unittest.TestCase		):
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Optional[int]):
  							torch.manual_seed(0)
  							A    =      UNetaDConditionModel(
  							    block_out_channels=(3_2, 6_4)  ,  layers_per_block=2  ,  sample_size=3_2  ,  in_channels=4  ,  out_channels=4  ,  down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")  ,  up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")  ,  cross_attention_dim=3_2  ,  )
  							A    =      DDIMScheduler(
  							    beta_start=0.0_0_0_8_5  ,  beta_end=0.0_1_2  ,  beta_schedule="scaled_linear"  ,  clip_sample=UpperCamelCase__  ,  set_alpha_to_one=UpperCamelCase__  ,  steps_offset=1  ,  )
  							torch.manual_seed(0)
  							A    =      AutoencoderKL(
  							    block_out_channels=[3_2, 6_4]  ,  in_channels=3  ,  out_channels=3  ,  down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]  ,  up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]  ,  latent_channels=4  ,  )
  							A    =      CLIPTextConfig(
  							    bos_token_id=0  ,  eos_token_id=2  ,  hidden_size=3_2  ,  intermediate_size=3_7  ,  layer_norm_eps=1E-05  ,  num_attention_heads=4  ,  num_hidden_layers=5  ,  pad_token_id=1  ,  vocab_size=1_0_0_0  ,  )
  							A    =      CLIPTextModel(UpperCamelCase__)
  							A    =      CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
  
  							A    ,					A    =      create_unet_lora_layers(UpperCamelCase__)
  							A    =      create_text_encoder_lora_layers(UpperCamelCase__)
  
  							A    =      {
  							    "unet": unet,
  							    "scheduler": scheduler,
  							    "vae": vae,
  							    "text_encoder": text_encoder,
  							    "tokenizer": tokenizer,
  							    "safety_checker": None,
  							    "feature_extractor": None,
  							}
  							A    =      {
  							    "unet_lora_layers": unet_lora_layers,
  							    "text_encoder_lora_layers": text_encoder_lora_layers,
  							    "unet_lora_attn_procs": unet_lora_attn_procs,
  							}
  							return pipeline_components, lora_components
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Dict):
  							A    =      1
  							A    =      1_0
  							A    =      4
  							A    =      (3_2, 3_2)
  
  							A    =      torch.manual_seed(0)
  							A    =      floats_tensor((batch_size, num_channels) + sizes)
  							A    =      torch.randint(1  ,  UpperCamelCase__  ,  size=(batch_size, sequence_length)  ,  generator=UpperCamelCase__)
  
  							A    =      {
  							    "prompt": "A painting of a squirrel eating a burger",
  							    "generator": generator,
  							    "num_inference_steps": 2,
  							    "guidance_scale": 6.0,
  							    "output_type": "numpy",
  							}
  
  							return noise, input_ids, pipeline_inputs
  
  							# copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	List[str]):
  							A    =      7_7
  
  							A    =      torch.randint(2  ,  5_6  ,  size=(1, max_seq_length)  ,  generator=torch.manual_seed(0))
  
  							A    =      {}
  							A    =      inputs
  							return prepared_inputs
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Any  ,  __SCREAMING_SNAKE_CASE				:	List[Any]):
  							A    ,					A    =      self.get_dummy_components()
  							LoraLoaderMixin.save_lora_weights(
  							    save_directory=UpperCamelCase__  ,  unet_lora_layers=lora_components["unet_lora_layers"]  ,  text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]  ,  )
  							self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__  ,  "pytorch_lora_weights.bin")))
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	str):
  							A    ,					A    =      self.get_dummy_components()
  							A    =      StableDiffusionPipeline(**UpperCamelCase__)
  							A    =      sd_pipe.to(UpperCamelCase__)
  							sd_pipe.set_progress_bar_config(disable=UpperCamelCase__)
  
  							A    ,					A    ,					A    =      self.get_dummy_inputs()
  
  							A    =      sd_pipe(**UpperCamelCase__).images
  							A    =      original_images[0, -3:, -3:, -1]
  
  							with tempfile.TemporaryDirectory() as tmpdirname:
  												LoraLoaderMixin.save_lora_weights(
  												    save_directory=UpperCamelCase__  ,  unet_lora_layers=lora_components["unet_lora_layers"]  ,  text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]  ,  )
  												self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__  ,  "pytorch_lora_weights.bin")))
  												sd_pipe.load_lora_weights(UpperCamelCase__)
  
  							A    =      sd_pipe(**UpperCamelCase__).images
  							A    =      lora_images[0, -3:, -3:, -1]
  
  							# Outputs shouldn't match.
  							self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__)  ,  torch.from_numpy(UpperCamelCase__)))
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	List[str]):
  							A    ,					A    =      self.get_dummy_components()
  							A    =      StableDiffusionPipeline(**UpperCamelCase__)
  							A    =      sd_pipe.to(UpperCamelCase__)
  							sd_pipe.set_progress_bar_config(disable=UpperCamelCase__)
  
  							A    ,					A    ,					A    =      self.get_dummy_inputs()
  
  							A    =      sd_pipe(**UpperCamelCase__).images
  							A    =      original_images[0, -3:, -3:, -1]
  
  							with tempfile.TemporaryDirectory() as tmpdirname:
  												LoraLoaderMixin.save_lora_weights(
  												    save_directory=UpperCamelCase__  ,  unet_lora_layers=lora_components["unet_lora_layers"]  ,  text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]  ,  safe_serialization=UpperCamelCase__  ,  )
  												self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__  ,  "pytorch_lora_weights.safetensors")))
  												sd_pipe.load_lora_weights(UpperCamelCase__)
  
  							A    =      sd_pipe(**UpperCamelCase__).images
  							A    =      lora_images[0, -3:, -3:, -1]
  
  							# Outputs shouldn't match.
  							self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__)  ,  torch.from_numpy(UpperCamelCase__)))
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	int):
  							A    ,					A    =      self.get_dummy_components()
  							A    =      lora_components["unet_lora_attn_procs"]
  							A    =      StableDiffusionPipeline(**UpperCamelCase__)
  							A    =      sd_pipe.to(UpperCamelCase__)
  							sd_pipe.set_progress_bar_config(disable=UpperCamelCase__)
  
  							A    ,					A    ,					A    =      self.get_dummy_inputs()
  
  							A    =      sd_pipe(**UpperCamelCase__).images
  							A    =      original_images[0, -3:, -3:, -1]
  
  							with tempfile.TemporaryDirectory() as tmpdirname:
  												A    =      sd_pipe.unet
  												unet.set_attn_processor(UpperCamelCase__)
  												unet.save_attn_procs(UpperCamelCase__)
  												self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__  ,  "pytorch_lora_weights.bin")))
  												sd_pipe.load_lora_weights(UpperCamelCase__)
  
  							A    =      sd_pipe(**UpperCamelCase__).images
  							A    =      lora_images[0, -3:, -3:, -1]
  
  							# Outputs shouldn't match.
  							self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__)  ,  torch.from_numpy(UpperCamelCase__)))
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	int):
  							A    ,					A    =      self.get_dummy_components()
  							A    =      StableDiffusionPipeline(**UpperCamelCase__)
  
  							A    =      self.get_dummy_tokens()
  
  							# inference without lora
  							A    =      pipe.text_encoder(**UpperCamelCase__)[0]
  							assert outputs_without_lora.shape == (1, 7_7, 3_2)
  
  							# create lora_attn_procs with zeroed out up.weights
  							A    =      create_text_encoder_lora_attn_procs(pipe.text_encoder)
  							set_lora_up_weights(UpperCamelCase__  ,  randn_weight=UpperCamelCase__)
  
  							# monkey patch
  							pipe._modify_text_encoder(UpperCamelCase__)
  
  							# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  							del text_attn_procs
  							gc.collect()
  
  							# inference with lora
  							A    =      pipe.text_encoder(**UpperCamelCase__)[0]
  							assert outputs_with_lora.shape == (1, 7_7, 3_2)
  
  							assert torch.allclose(
  							    UpperCamelCase__  ,  UpperCamelCase__), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"
  
  							# create lora_attn_procs with randn up.weights
  							A    =      create_text_encoder_lora_attn_procs(pipe.text_encoder)
  							set_lora_up_weights(UpperCamelCase__  ,  randn_weight=UpperCamelCase__)
  
  							# monkey patch
  							pipe._modify_text_encoder(UpperCamelCase__)
  
  							# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  							del text_attn_procs
  							gc.collect()
  
  							# inference with lora
  							A    =      pipe.text_encoder(**UpperCamelCase__)[0]
  							assert outputs_with_lora.shape == (1, 7_7, 3_2)
  
  							assert not torch.allclose(
  							    UpperCamelCase__  ,  UpperCamelCase__), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Any):
  							A    ,					A    =      self.get_dummy_components()
  							A    =      StableDiffusionPipeline(**UpperCamelCase__)
  
  							A    =      self.get_dummy_tokens()
  
  							# inference without lora
  							A    =      pipe.text_encoder(**UpperCamelCase__)[0]
  							assert outputs_without_lora.shape == (1, 7_7, 3_2)
  
  							# create lora_attn_procs with randn up.weights
  							A    =      create_text_encoder_lora_attn_procs(pipe.text_encoder)
  							set_lora_up_weights(UpperCamelCase__  ,  randn_weight=UpperCamelCase__)
  
  							# monkey patch
  							pipe._modify_text_encoder(UpperCamelCase__)
  
  							# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  							del text_attn_procs
  							gc.collect()
  
  							# inference with lora
  							A    =      pipe.text_encoder(**UpperCamelCase__)[0]
  							assert outputs_with_lora.shape == (1, 7_7, 3_2)
  
  							assert not torch.allclose(
  							    UpperCamelCase__  ,  UpperCamelCase__), "lora outputs should be different to without lora outputs"
  
  							# remove monkey patch
  							pipe._remove_text_encoder_monkey_patch()
  
  							# inference with removed lora
  							A    =      pipe.text_encoder(**UpperCamelCase__)[0]
  							assert outputs_without_lora_removed.shape == (1, 7_7, 3_2)
  
  							assert torch.allclose(
  							    UpperCamelCase__  ,  UpperCamelCase__), "remove lora monkey patch should restore the original outputs"
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	List[str]):
  							A    ,					A    =      self.get_dummy_components()
  							A    =      StableDiffusionPipeline(**UpperCamelCase__)
  							A    =      sd_pipe.to(UpperCamelCase__)
  							sd_pipe.set_progress_bar_config(disable=UpperCamelCase__)
  
  							A    ,					A    ,					A    =      self.get_dummy_inputs()
  
  							with tempfile.TemporaryDirectory() as tmpdirname:
  												LoraLoaderMixin.save_lora_weights(
  												    save_directory=UpperCamelCase__  ,  unet_lora_layers=lora_components["unet_lora_layers"]  ,  text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]  ,  )
  												self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__  ,  "pytorch_lora_weights.bin")))
  												sd_pipe.load_lora_weights(UpperCamelCase__)
  
  							A    =      sd_pipe(**UpperCamelCase__).images
  							A    =      lora_images[0, -3:, -3:, -1]
  
  							A    =      sd_pipe(**UpperCamelCase__  ,  cross_attention_kwargs={"scale": 0.5}).images
  							A    =      lora_images_with_scale[0, -3:, -3:, -1]
  
  							# Outputs shouldn't match.
  							self.assertFalse(
  							    torch.allclose(torch.from_numpy(UpperCamelCase__)  ,  torch.from_numpy(UpperCamelCase__)))
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	List[Any]):
  							with tempfile.TemporaryDirectory() as tmpdirname:
  												self.create_lora_weight_file(UpperCamelCase__)
  
  												A    ,					A    =      self.get_dummy_components()
  												A    =      StableDiffusionPipeline(**UpperCamelCase__)
  												A    =      sd_pipe.to(UpperCamelCase__)
  												sd_pipe.set_progress_bar_config(disable=UpperCamelCase__)
  
  												# check if vanilla attention processors are used
  												for _, module in sd_pipe.unet.named_modules():
  																	if isinstance(UpperCamelCase__  ,  UpperCamelCase__):
  																						self.assertIsInstance(module.processor  ,  (AttnProcessor, AttnProcessor2_0))
  
              # load LoRA weight file
  												sd_pipe.load_lora_weights(UpperCamelCase__)
  
  												# check if lora attention processors are used
  												for _, module in sd_pipe.unet.named_modules():
  																	if isinstance(UpperCamelCase__  ,  UpperCamelCase__):
  																						A    =      (
  																						    LoRAAttnProcessor2_0 if hasattr(UpperCamelCase__  ,  "scaled_dot_product_attention") else LoRAAttnProcessor
  																						)
  																						self.assertIsInstance(module.processor  ,  UpperCamelCase__)
  
  
  		@unittest.skipIf(torch_device != "cuda"  ,  "This test is supposed to run on GPU")
  		def       SCREAMING_SNAKE_CASE__     (self				:	int):
  							with tempfile.TemporaryDirectory() as tmpdirname:
  												self.create_lora_weight_file(UpperCamelCase__)
  
  												A    ,					A    =      self.get_dummy_components()
  												A    =      StableDiffusionPipeline(**UpperCamelCase__)
  												A    =      sd_pipe.to(UpperCamelCase__)
  												sd_pipe.set_progress_bar_config(disable=UpperCamelCase__)
  
  												# enable XFormers
  												sd_pipe.enable_xformers_memory_efficient_attention()
  
  												# check if xFormers attention processors are used
  												for _, module in sd_pipe.unet.named_modules():
  																	if isinstance(UpperCamelCase__  ,  UpperCamelCase__):
  																						self.assertIsInstance(module.processor  ,  UpperCamelCase__)
  
              # load LoRA weight file
  												sd_pipe.load_lora_weights(UpperCamelCase__)
  
  												# check if lora attention processors are used
  												for _, module in sd_pipe.unet.named_modules():
  																	if isinstance(UpperCamelCase__  ,  UpperCamelCase__):
  																						self.assertIsInstance(module.processor  ,  UpperCamelCase__)
  
  
  		@unittest.skipIf(torch_device != "cuda"  ,  "This test is supposed to run on GPU")
  		def       SCREAMING_SNAKE_CASE__     (self				:	Union[str, Any]):
  							A    ,					A    =      self.get_dummy_components()
  							A    =      StableDiffusionPipeline(**UpperCamelCase__)
  							A    =      sd_pipe.to(UpperCamelCase__)
  							sd_pipe.set_progress_bar_config(disable=UpperCamelCase__)
  
  							A    ,					A    ,					A    =      self.get_dummy_inputs()
  
  							# enable XFormers
  							sd_pipe.enable_xformers_memory_efficient_attention()
  
  							A    =      sd_pipe(**UpperCamelCase__).images
  							A    =      original_images[0, -3:, -3:, -1]
  
  							with tempfile.TemporaryDirectory() as tmpdirname:
  												LoraLoaderMixin.save_lora_weights(
  												    save_directory=UpperCamelCase__  ,  unet_lora_layers=lora_components["unet_lora_layers"]  ,  text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]  ,  )
  												self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__  ,  "pytorch_lora_weights.bin")))
  												sd_pipe.load_lora_weights(UpperCamelCase__)
  
  							A    =      sd_pipe(**UpperCamelCase__).images
  							A    =      lora_images[0, -3:, -3:, -1]
  
  							# Outputs shouldn't match.
  							self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__)  ,  torch.from_numpy(UpperCamelCase__)))
  
  
  
  
  
  
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"},
  							    ]  ,  )
  
  
  
  
  
  