


'''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				(			*__lowerCamelCase       :  Dict ,					**__lowerCamelCase       :  Dict   ):
      pass




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


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Tuple ,					__lowerCamelCase       :  List[str] ,					__lowerCamelCase       :  List[str] ,					__lowerCamelCase       :  int   ):
    UpperCAmelCase__  :Union[str, Any]            =			ImageClassificationPipeline(model=__lowerCamelCase ,					image_processor=__lowerCamelCase ,					top_k=2   )
    UpperCAmelCase__  :Union[str, Any]            =			[
        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       :  str ,					__lowerCamelCase       :  List[str] ,					__lowerCamelCase       :  str   ):
    UpperCAmelCase__  :Tuple            =			image_classifier('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )

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

    import datasets

    UpperCAmelCase__  :List[str]            =			datasets.load_dataset('''hf-internal-testing/fixtures_image_utils''' ,					'''image''' ,					split='''test'''   )

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


 @require_torch
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Tuple   ):
    UpperCAmelCase__  :Union[str, Any]            =			'''hf-internal-testing/tiny-random-vit'''
    UpperCAmelCase__  :str            =			pipeline('''image-classification''' ,					model=__lowerCamelCase   )

    UpperCAmelCase__  :Union[str, Any]            =			image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''   )
    self.assertEqual(
        nested_simplify(__lowerCamelCase ,					decimals=4   ) ,					[{'''label''': '''LABEL_1''', '''score''': 0.5_74}, {'''label''': '''LABEL_0''', '''score''': 0.4_26}] ,					)

    UpperCAmelCase__  :Optional[Any]            =			image_classifier(
        [
            '''http://images.cocodataset.org/val2017/000000039769.jpg''',
            '''http://images.cocodataset.org/val2017/000000039769.jpg''',
        ] ,					top_k=2 ,					)
    self.assertEqual(
        nested_simplify(__lowerCamelCase ,					decimals=4   ) ,					[
            [{'''label''': '''LABEL_1''', '''score''': 0.5_74}, {'''label''': '''LABEL_0''', '''score''': 0.4_26}],
            [{'''label''': '''LABEL_1''', '''score''': 0.5_74}, {'''label''': '''LABEL_0''', '''score''': 0.4_26}],
        ] ,					)


 @require_tf
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Optional[int]   ):
    UpperCAmelCase__  :Optional[Any]            =			'''hf-internal-testing/tiny-random-vit'''
    UpperCAmelCase__  :Optional[int]            =			pipeline('''image-classification''' ,					model=__lowerCamelCase ,					framework='''tf'''   )

    UpperCAmelCase__  :Tuple            =			image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''   )
    self.assertEqual(
        nested_simplify(__lowerCamelCase ,					decimals=4   ) ,					[{'''label''': '''LABEL_1''', '''score''': 0.5_74}, {'''label''': '''LABEL_0''', '''score''': 0.4_26}] ,					)

    UpperCAmelCase__  :Optional[Any]            =			image_classifier(
        [
            '''http://images.cocodataset.org/val2017/000000039769.jpg''',
            '''http://images.cocodataset.org/val2017/000000039769.jpg''',
        ] ,					top_k=2 ,					)
    self.assertEqual(
        nested_simplify(__lowerCamelCase ,					decimals=4   ) ,					[
            [{'''label''': '''LABEL_1''', '''score''': 0.5_74}, {'''label''': '''LABEL_0''', '''score''': 0.4_26}],
            [{'''label''': '''LABEL_1''', '''score''': 0.5_74}, {'''label''': '''LABEL_0''', '''score''': 0.4_26}],
        ] ,					)


 def 					__SCREAMING_SNAKE_CASE				(			self       :  int   ):
    UpperCAmelCase__  :Optional[int]            =			PreTrainedTokenizer()

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

    self.assertIs(image_classifier.tokenizer ,					__lowerCamelCase   )





 @slow
 @require_torch
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Dict   ):
    # 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__  :Optional[int]            =			pipeline('''image-classification''' ,					model='''deepmind/vision-perceiver-conv'''   )
    UpperCAmelCase__  :Dict            =			image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''   )
    self.assertEqual(
        nested_simplify(__lowerCamelCase ,					decimals=4   ) ,					[
            {'''score''': 0.43_85, '''label''': '''tabby, tabby cat'''},
            {'''score''': 0.3_21, '''label''': '''tiger cat'''},
            {'''score''': 0.05_02, '''label''': '''Egyptian cat'''},
            {'''score''': 0.01_37, '''label''': '''crib, cot'''},
            {'''score''': 0.0_07, '''label''': '''radiator'''},
        ] ,					)

    UpperCAmelCase__  :str            =			pipeline('''image-classification''' ,					model='''deepmind/vision-perceiver-fourier'''   )
    UpperCAmelCase__  :List[str]            =			image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''   )
    self.assertEqual(
        nested_simplify(__lowerCamelCase ,					decimals=4   ) ,					[
            {'''score''': 0.56_58, '''label''': '''tabby, tabby cat'''},
            {'''score''': 0.13_09, '''label''': '''tiger cat'''},
            {'''score''': 0.07_22, '''label''': '''Egyptian cat'''},
            {'''score''': 0.07_07, '''label''': '''remote control, remote'''},
            {'''score''': 0.00_82, '''label''': '''computer keyboard, keypad'''},
        ] ,					)

    UpperCAmelCase__  :List[str]            =			pipeline('''image-classification''' ,					model='''deepmind/vision-perceiver-learned'''   )
    UpperCAmelCase__  :List[Any]            =			image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''   )
    self.assertEqual(
        nested_simplify(__lowerCamelCase ,					decimals=4   ) ,					[
            {'''score''': 0.30_22, '''label''': '''tabby, tabby cat'''},
            {'''score''': 0.23_62, '''label''': '''Egyptian cat'''},
            {'''score''': 0.18_56, '''label''': '''tiger cat'''},
            {'''score''': 0.03_24, '''label''': '''remote control, remote'''},
            {'''score''': 0.00_96, '''label''': '''quilt, comforter, comfort, puff'''},
        ] ,					)







'''simple docstring'''





import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    require_torch_gpu,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()




class 							UpperCAmelCase ( _snake_case	,   _snake_case	,   unittest.TestCase	):
 UpperCAmelCase				=				StableDiffusionParadigmsPipeline
 UpperCAmelCase				=				TEXT_TO_IMAGE_PARAMS
 UpperCAmelCase				=				TEXT_TO_IMAGE_BATCH_PARAMS
 UpperCAmelCase				=				TEXT_TO_IMAGE_IMAGE_PARAMS
 UpperCAmelCase				=				TEXT_TO_IMAGE_IMAGE_PARAMS


 def 					__SCREAMING_SNAKE_CASE				(			self       :  int   ):
    torch.manual_seed(0   )
    UpperCAmelCase__  :Optional[int]            =			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 ,					attention_head_dim=(2, 4) ,					use_linear_projection=__lowerCamelCase ,					)
    UpperCAmelCase__  :Union[str, Any]            =			DDIMParallelScheduler(
        beta_start=0.0_00_85 ,					beta_end=0.0_12 ,					beta_schedule='''scaled_linear''' ,					clip_sample=__lowerCamelCase ,					set_alpha_to_one=__lowerCamelCase ,					)
    torch.manual_seed(0   )
    UpperCAmelCase__  :Tuple            =			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 ,					sample_size=1_2_8 ,					)
    torch.manual_seed(0   )
    UpperCAmelCase__  :Tuple            =			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 ,					hidden_act='''gelu''' ,					projection_dim=5_1_2 ,					)
    UpperCAmelCase__  :List[Any]            =			CLIPTextModel(__lowerCamelCase   )
    UpperCAmelCase__  :Tuple            =			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )

    UpperCAmelCase__  :int            =			{
        '''unet''': unet,
        '''scheduler''': scheduler,
        '''vae''': vae,
        '''text_encoder''': text_encoder,
        '''tokenizer''': tokenizer,
        '''safety_checker''': None,
        '''feature_extractor''': None,
    }
    return components


 def 					__SCREAMING_SNAKE_CASE				(			self       :  str ,					__lowerCamelCase       :  List[Any] ,					__lowerCamelCase       :  Any=0   ):
    if str(__lowerCamelCase   ).startswith('''mps'''   ):
       UpperCAmelCase__  :str            =			torch.manual_seed(__lowerCamelCase   )
    else:
       UpperCAmelCase__  :Union[str, Any]            =			torch.Generator(device=__lowerCamelCase   ).manual_seed(__lowerCamelCase   )
    UpperCAmelCase__  :Union[str, Any]            =			{
        '''prompt''': '''a photograph of an astronaut riding a horse''',
        '''generator''': generator,
        '''num_inference_steps''': 1_0,
        '''guidance_scale''': 6.0,
        '''output_type''': '''numpy''',
        '''parallel''': 3,
        '''debug''': True,
    }
    return inputs


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Dict   ):
    UpperCAmelCase__  :Dict            =			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
    UpperCAmelCase__  :Dict            =			self.get_dummy_components()
    UpperCAmelCase__  :str            =			StableDiffusionParadigmsPipeline(**__lowerCamelCase   )
    UpperCAmelCase__  :List[Any]            =			sd_pipe.to(__lowerCamelCase   )
    sd_pipe.set_progress_bar_config(disable=__lowerCamelCase   )

    UpperCAmelCase__  :Optional[int]            =			self.get_dummy_inputs(__lowerCamelCase   )
    UpperCAmelCase__  :Any            =			sd_pipe(**__lowerCamelCase   ).images
    UpperCAmelCase__  :Union[str, Any]            =			image[0, -3:, -3:, -1]
    assert image.shape == (1, 6_4, 6_4, 3)

    UpperCAmelCase__  :List[Any]            =			np.array([0.47_73, 0.54_17, 0.47_23, 0.49_25, 0.56_31, 0.47_52, 0.52_40, 0.49_35, 0.50_23]   )

    assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Dict   ):
    UpperCAmelCase__  :Any            =			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
    UpperCAmelCase__  :Dict            =			self.get_dummy_components()
    torch.manual_seed(0   )
    UpperCAmelCase__  :Tuple            =			DDPMParallelScheduler()
    torch.manual_seed(0   )
    UpperCAmelCase__  :List[str]            =			StableDiffusionParadigmsPipeline(**__lowerCamelCase   )
    UpperCAmelCase__  :Optional[int]            =			sd_pipe.to(__lowerCamelCase   )
    sd_pipe.set_progress_bar_config(disable=__lowerCamelCase   )

    UpperCAmelCase__  :Optional[int]            =			self.get_dummy_inputs(__lowerCamelCase   )
    UpperCAmelCase__  :Optional[Any]            =			sd_pipe(**__lowerCamelCase   ).images
    UpperCAmelCase__  :Dict            =			image[0, -3:, -3:, -1]
    assert image.shape == (1, 6_4, 6_4, 3)

    UpperCAmelCase__  :List[str]            =			np.array([0.35_73, 0.44_20, 0.49_60, 0.47_99, 0.37_96, 0.38_79, 0.48_19, 0.43_65, 0.44_68]   )

    assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Dict   ):
    super().test_inference_batch_consistent(batch_sizes=[1, 2]   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  List[str]   ):
    super().test_inference_batch_single_identical(batch_size=2 ,					expected_max_diff=3e-3   )





 def 					__SCREAMING_SNAKE_CASE				(			self       :  Dict   ):
    UpperCAmelCase__  :int            =			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
    UpperCAmelCase__  :str            =			self.get_dummy_components()
    UpperCAmelCase__  :Any            =			StableDiffusionParadigmsPipeline(**__lowerCamelCase   )
    UpperCAmelCase__  :List[str]            =			sd_pipe.to(__lowerCamelCase   )
    sd_pipe.set_progress_bar_config(disable=__lowerCamelCase   )

    UpperCAmelCase__  :Tuple            =			self.get_dummy_inputs(__lowerCamelCase   )
    UpperCAmelCase__  :Optional[int]            =			'''french fries'''
    UpperCAmelCase__  :Any            =			sd_pipe(**__lowerCamelCase ,					negative_prompt=__lowerCamelCase   )
    UpperCAmelCase__  :int            =			output.images
    UpperCAmelCase__  :Tuple            =			image[0, -3:, -3:, -1]

    assert image.shape == (1, 6_4, 6_4, 3)

    UpperCAmelCase__  :Tuple            =			np.array([0.47_71, 0.54_20, 0.46_83, 0.49_18, 0.56_36, 0.47_25, 0.52_30, 0.49_23, 0.50_15]   )

    assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2




@slow
@require_torch_gpu
class 							UpperCAmelCase ( unittest.TestCase	):


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Dict   ):
    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Optional[Any] ,					__lowerCamelCase       :  Tuple=0   ):
    UpperCAmelCase__  :List[Any]            =			torch.Generator(device=__lowerCamelCase   ).manual_seed(__lowerCamelCase   )
    UpperCAmelCase__  :List[str]            =			{
        '''prompt''': '''a photograph of an astronaut riding a horse''',
        '''generator''': generator,
        '''num_inference_steps''': 1_0,
        '''guidance_scale''': 7.5,
        '''output_type''': '''numpy''',
        '''parallel''': 3,
        '''debug''': True,
    }
    return inputs





 def 					__SCREAMING_SNAKE_CASE				(			self       :  int   ):
    UpperCAmelCase__  :Dict            =			'''stabilityai/stable-diffusion-2-base'''
    UpperCAmelCase__  :Union[str, Any]            =			DDIMParallelScheduler.from_pretrained(__lowerCamelCase ,					subfolder='''scheduler'''   )
    UpperCAmelCase__  :Dict            =			StableDiffusionParadigmsPipeline.from_pretrained(__lowerCamelCase ,					scheduler=__lowerCamelCase ,					safety_checker=__lowerCamelCase   )
    pipe.to(__lowerCamelCase   )
    pipe.set_progress_bar_config(disable=__lowerCamelCase   )
    pipe.enable_attention_slicing()

    UpperCAmelCase__  :Dict            =			self.get_inputs()
    UpperCAmelCase__  :int            =			pipe(**__lowerCamelCase   ).images
    UpperCAmelCase__  :List[str]            =			image[0, -3:, -3:, -1].flatten()

    assert image.shape == (1, 5_1_2, 5_1_2, 3)

    UpperCAmelCase__  :Optional[int]            =			np.array([0.96_22, 0.96_02, 0.97_48, 0.95_91, 0.96_30, 0.96_91, 0.96_61, 0.96_31, 0.97_41]   )

    assert np.abs(expected_slice - image_slice   ).max() < 1e-2



