
import unittest

from transformers import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING, is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
					from PIL import Image
else:


					class 				lowercase					:



							@staticmethod
							def __UpperCamelCase ( *A_				,      **A_       )  ->					List[str]:
									"""simple docstring"""
									pass


@is_pipeline_test
@require_torch
@require_vision
class 				lowercase					(		unittest.TestCase   ):
		__lowercase       :       Optional[Any]	     =				MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING



		def __UpperCamelCase ( self				,      A_				,      A_				,      A_       )  ->					Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase		=     pipeline('visual-question-answering'				,      model='hf-internal-testing/tiny-vilt-random-vqa'       )
				UpperCamelCase		=     [
				    {
				        'image': Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'       ),
				        'question': 'How many cats are there?',
				    },
				    {
				        'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
				        'question': 'How many cats are there?',
				    },
				]
				return vqa_pipeline, examples



		def __UpperCamelCase ( self				,      A_				,      A_       )  ->					Tuple:
				"""simple docstring"""
				UpperCamelCase		=     vqa_pipeline(A_				,      top_k=1       )
				self.assertEqual(
				    A_				,      [
				        [{'score': ANY(A_       ), 'answer': ANY(A_       )}],
				        [{'score': ANY(A_       ), 'answer': ANY(A_       )}],
				    ]				,      )



		@require_torch
		def __UpperCamelCase ( self       )  ->					List[str]:
				"""simple docstring"""
				UpperCamelCase		=     pipeline('visual-question-answering'				,      model='hf-internal-testing/tiny-vilt-random-vqa'       )
				UpperCamelCase		=     './tests/fixtures/tests_samples/COCO/000000039769.png'
				UpperCamelCase		=     'How many cats are there?'

				UpperCamelCase		=     vqa_pipeline(image=A_				,      question='How many cats are there?'				,      top_k=2       )
				self.assertEqual(
				    A_				,      [{'score': ANY(A_       ), 'answer': ANY(A_       )}, {'score': ANY(A_       ), 'answer': ANY(A_       )}]       )

				UpperCamelCase		=     vqa_pipeline({'image': image, 'question': question}				,      top_k=2       )
				self.assertEqual(
				    A_				,      [{'score': ANY(A_       ), 'answer': ANY(A_       )}, {'score': ANY(A_       ), 'answer': ANY(A_       )}]       )



		@slow
		@require_torch
		def __UpperCamelCase ( self       )  ->					int:
				"""simple docstring"""
				UpperCamelCase		=     pipeline('visual-question-answering'				,      model='dandelin/vilt-b32-finetuned-vqa'       )
				UpperCamelCase		=     './tests/fixtures/tests_samples/COCO/000000039769.png'
				UpperCamelCase		=     'How many cats are there?'

				UpperCamelCase		=     vqa_pipeline(image=A_				,      question=A_				,      top_k=2       )
				self.assertEqual(
				    nested_simplify(A_				,      decimals=4       )				,      [{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]       )

				UpperCamelCase		=     vqa_pipeline({'image': image, 'question': question}				,      top_k=2       )
				self.assertEqual(
				    nested_simplify(A_				,      decimals=4       )				,      [{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]       )

				UpperCamelCase		=     vqa_pipeline(
				    [{'image': image, 'question': question}, {'image': image, 'question': question}]				,      top_k=2       )
				self.assertEqual(
				    nested_simplify(A_				,      decimals=4       )				,      [[{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]] * 2				,      )



		@require_tf
		@unittest.skip('Visual question answering not implemented in TF'       )
		def __UpperCamelCase ( self       )  ->					List[Any]:
				"""simple docstring"""
				pass


import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()


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



		def __UpperCamelCase ( self       )  ->					Dict:
				"""simple docstring"""
				# clean up the VRAM after each test
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()



		def __UpperCamelCase ( self       )  ->					str:
				"""simple docstring"""
				UpperCamelCase		=     StableDiffusionKDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'       )
				UpperCamelCase		=     sd_pipe.to(A_       )
				sd_pipe.set_progress_bar_config(disable=A_       )

				sd_pipe.set_scheduler('sample_euler'       )

				UpperCamelCase		=     'A painting of a squirrel eating a burger'
				UpperCamelCase		=     torch.manual_seed(0       )
				UpperCamelCase		=     sd_pipe([prompt]				,      generator=A_				,      guidance_scale=9.0				,      num_inference_steps=20				,      output_type='np'       )

				UpperCamelCase		=     output.images

				UpperCamelCase		=     image[0, -3:, -3:, -1]

				assert image.shape == (1, 512, 512, 3)
				UpperCamelCase		=     np.array([0.0447, 0.0492, 0.0468, 0.0408, 0.0383, 0.0408, 0.0354, 0.0380, 0.0339]       )

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



		def __UpperCamelCase ( self       )  ->					Any:
				"""simple docstring"""
				UpperCamelCase		=     StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'       )
				UpperCamelCase		=     sd_pipe.to(A_       )
				sd_pipe.set_progress_bar_config(disable=A_       )

				sd_pipe.set_scheduler('sample_euler'       )

				UpperCamelCase		=     'A painting of a squirrel eating a burger'
				UpperCamelCase		=     torch.manual_seed(0       )
				UpperCamelCase		=     sd_pipe([prompt]				,      generator=A_				,      guidance_scale=9.0				,      num_inference_steps=20				,      output_type='np'       )

				UpperCamelCase		=     output.images

				UpperCamelCase		=     image[0, -3:, -3:, -1]

				assert image.shape == (1, 512, 512, 3)
				UpperCamelCase		=     np.array([0.1237, 0.1320, 0.1438, 0.1359, 0.1390, 0.1132, 0.1277, 0.1175, 0.1112]       )

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



		def __UpperCamelCase ( self       )  ->					Optional[int]:
				"""simple docstring"""
				UpperCamelCase		=     StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'       )
				UpperCamelCase		=     sd_pipe.to(A_       )
				sd_pipe.set_progress_bar_config(disable=A_       )

				sd_pipe.set_scheduler('sample_dpmpp_2m'       )

				UpperCamelCase		=     'A painting of a squirrel eating a burger'
				UpperCamelCase		=     torch.manual_seed(0       )
				UpperCamelCase		=     sd_pipe(
				    [prompt]				,      generator=A_				,      guidance_scale=7.5				,      num_inference_steps=15				,      output_type='np'				,      use_karras_sigmas=A_				,      )

				UpperCamelCase		=     output.images

				UpperCamelCase		=     image[0, -3:, -3:, -1]

				assert image.shape == (1, 512, 512, 3)
				UpperCamelCase		=     np.array(
				    [0.1138_1689, 0.1211_2921, 0.138_9457, 0.1254_9606, 0.124_4964, 0.1083_1517, 0.1156_2866, 0.1086_7816, 0.1049_9048]       )

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