

"""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__)))








"""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"},
							    ]  ,  )





