
import unittest

import torch

from diffusers import VQModel
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()







class 			__A( a  ,   a  ,   unittest.TestCase			):
				snake_case_						   =    VQModel
				snake_case_						   =    '''sample'''




				@property
				def 				SCREAMING_SNAKE_CASE_		(     self		,     _snake_case=(32, 32)				)    ->      Union[str, Any]:


								'''simple docstring'''




								__a										=    4
								__a										=    3

								__a										=    floats_tensor((batch_size, num_channels) + sizes				).to(_snake_case				)

								return {"sample": image}




				@property
				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      str:


								'''simple docstring'''




								return (3, 32, 32)




				@property
				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Optional[int]:


								'''simple docstring'''




								return (3, 32, 32)




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Optional[Any]:


								'''simple docstring'''




								__a										=    {
								    '''block_out_channels''': [32, 64],
								    '''in_channels''': 3,
								    '''out_channels''': 3,
								    '''down_block_types''': ['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],
								    '''up_block_types''': ['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],
								    '''latent_channels''': 3,
								}
								__a										=    self.dummy_input
								return init_dict, inputs_dict




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      List[str]:


								'''simple docstring'''




								pass




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Tuple:


								'''simple docstring'''




								pass




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Dict:


								'''simple docstring'''




								__a							,     __a										=    VQModel.from_pretrained('''fusing/vqgan-dummy'''		,     output_loading_info=_snake_case				)
								self.assertIsNotNone(_snake_case				)
								self.assertEqual(len(loading_info['''missing_keys''']				)		,     0				)

								model.to(_snake_case				)
								__a										=    model(**self.dummy_input				)

								assert image is not None, "Make sure output is not None"




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Optional[int]:


								'''simple docstring'''




								__a										=    VQModel.from_pretrained('''fusing/vqgan-dummy'''				)
								model.to(_snake_case				).eval()

								torch.manual_seed(0				)
								if torch.cuda.is_available():
												torch.cuda.manual_seed_all(0				)

								__a										=    torch.randn(1		,     model.config.in_channels		,     model.config.sample_size		,     model.config.sample_size				)
								__a										=    image.to(_snake_case				)
								with torch.no_grad():
												__a										=    model(_snake_case				).sample

								__a										=    output[0, -1, -3:, -3:].flatten().cpu()
								# fmt: off
								__a										=    torch.tensor([-0.0153, -0.4044, -0.1880, -0.5161, -0.2418, -0.4072, -0.1612, -0.0633, -0.0143]				)
								# fmt: on
								self.assertTrue(torch.allclose(_snake_case		,     _snake_case		,     atol=1E-3				)				)







"""simple docstring"""



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







        @staticmethod
        def 			UpperCamelCase_      (			*_lowerCamelCase							,		**_lowerCamelCase       ):
          pass

@is_pipeline_test
@require_torch
@require_vision
class        a     (   unittest.TestCase	):
    UpperCAmelCase_ :     Union[str, Any]	     =MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING







    def 			UpperCamelCase_      (			self							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       ):
      lowercase							    =       pipeline('visual-question-answering'							,		model='hf-internal-testing/tiny-vilt-random-vqa'       )
      lowercase							    =       [
          {
              '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							,		_lowerCamelCase							,		_lowerCamelCase       ):
      lowercase							    =       vqa_pipeline(_lowerCamelCase							,		top_k=1       )
      self.assertEqual(
          _lowerCamelCase							,		[
              [{'score': ANY(_lowerCamelCase       ), 'answer': ANY(_lowerCamelCase       )}],
              [{'score': ANY(_lowerCamelCase       ), 'answer': ANY(_lowerCamelCase       )}],
          ]							,		)







    @require_torch
    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       pipeline('visual-question-answering'							,		model='hf-internal-testing/tiny-vilt-random-vqa'       )
      lowercase							    =       './tests/fixtures/tests_samples/COCO/000000039769.png'
      lowercase							    =       'How many cats are there?'

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

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







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

      lowercase							    =       vqa_pipeline(image=_lowerCamelCase							,		question=_lowerCamelCase							,		top_k=2       )
      self.assertEqual(
          nested_simplify(_lowerCamelCase							,		decimals=4       )							,		[{'score': 0.8_7_9_9, 'answer': '2'}, {'score': 0.2_9_6, 'answer': '1'}]       )

      lowercase							    =       vqa_pipeline({'image': image, 'question': question}							,		top_k=2       )
      self.assertEqual(
          nested_simplify(_lowerCamelCase							,		decimals=4       )							,		[{'score': 0.8_7_9_9, 'answer': '2'}, {'score': 0.2_9_6, 'answer': '1'}]       )

      lowercase							    =       vqa_pipeline(
          [{'image': image, 'question': question}, {'image': image, 'question': question}]							,		top_k=2       )
      self.assertEqual(
          nested_simplify(_lowerCamelCase							,		decimals=4       )							,		[[{'score': 0.8_7_9_9, 'answer': '2'}, {'score': 0.2_9_6, 'answer': '1'}]] * 2							,		)







    @require_tf
    @unittest.skip('Visual question answering not implemented in TF'       )
    def 			UpperCamelCase_      (			self       ):
      pass


