
import unittest

from transformers import LiltConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       LiltForQuestionAnswering,
       LiltForSequenceClassification,
       LiltForTokenClassification,
       LiltModel,
   )
   from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST







class   lowerCamelCase	:





     def __init__(self   :					List[str]       ,					_A   :					Tuple       ,					_A   :					str=1_3       ,					_A   :					List[Any]=7       ,					_A   :					Dict=True       ,					_A   :					Optional[int]=True       ,					_A   :					Optional[int]=True       ,					_A   :					Any=True       ,					_A   :					Any=9_9       ,					_A   :					Optional[int]=2_4       ,					_A   :					Tuple=2       ,					_A   :					int=6       ,					_A   :					Dict=3_7       ,					_A   :					List[str]="gelu"       ,					_A   :					str=0.1       ,					_A   :					List[Any]=0.1       ,					_A   :					Any=5_1_2       ,					_A   :					Union[str, Any]=1_6       ,					_A   :					int=2       ,					_A   :					Optional[Any]=0.02       ,					_A   :					Any=3       ,					_A   :					Tuple=None       ,					_A   :					Optional[int]=1_0_0_0       ,					)		->		Union[str, Any]:
         snake_case				  =      parent
         snake_case				  =      batch_size
         snake_case				  =      seq_length
         snake_case				  =      is_training
         snake_case				  =      use_input_mask
         snake_case				  =      use_token_type_ids
         snake_case				  =      use_labels
         snake_case				  =      vocab_size
         snake_case				  =      hidden_size
         snake_case				  =      num_hidden_layers
         snake_case				  =      num_attention_heads
         snake_case				  =      intermediate_size
         snake_case				  =      hidden_act
         snake_case				  =      hidden_dropout_prob
         snake_case				  =      attention_probs_dropout_prob
         snake_case				  =      max_position_embeddings
         snake_case				  =      type_vocab_size
         snake_case				  =      type_sequence_label_size
         snake_case				  =      initializer_range
         snake_case				  =      num_labels
         snake_case				  =      scope
         snake_case				  =      range_bbox





     def 	UpperCAmelCase(self   :					str     )		->		List[Any]:
         snake_case				  =      ids_tensor([self.batch_size, self.seq_length]       ,					self.vocab_size     )

         snake_case				  =      ids_tensor([self.batch_size, self.seq_length, 4]       ,					self.range_bbox     )
         # Ensure that bbox is legal
         for i in range(bbox.shape[0]     ):
             for j in range(bbox.shape[1]     ):
                 if bbox[i, j, 3] < bbox[i, j, 1]:
                     snake_case				  =      bbox[i, j, 3]
                     snake_case				  =      bbox[i, j, 1]
                     snake_case				  =      t
                 if bbox[i, j, 2] < bbox[i, j, 0]:
                     snake_case				  =      bbox[i, j, 2]
                     snake_case				  =      bbox[i, j, 0]
                     snake_case				  =      t

         snake_case				  =      None
         if self.use_input_mask:
             snake_case				  =      ids_tensor([self.batch_size, self.seq_length]       ,					vocab_size=2     )

         snake_case				  =      None
         if self.use_token_type_ids:
             snake_case				  =      ids_tensor([self.batch_size, self.seq_length]       ,					self.type_vocab_size     )

         snake_case				  =      None
         snake_case				  =      None
         if self.use_labels:
             snake_case				  =      ids_tensor([self.batch_size]       ,					self.type_sequence_label_size     )
             snake_case				  =      ids_tensor([self.batch_size, self.seq_length]       ,					self.num_labels     )

         snake_case				  =      self.get_config()

         return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels





     def 	UpperCAmelCase(self   :					Optional[Any]     )		->		str:
         return LiltConfig(
             vocab_size=self.vocab_size       ,					hidden_size=self.hidden_size       ,					num_hidden_layers=self.num_hidden_layers       ,					num_attention_heads=self.num_attention_heads       ,					intermediate_size=self.intermediate_size       ,					hidden_act=self.hidden_act       ,					hidden_dropout_prob=self.hidden_dropout_prob       ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,					max_position_embeddings=self.max_position_embeddings       ,					type_vocab_size=self.type_vocab_size       ,					initializer_range=self.initializer_range       ,					)





     def 	UpperCAmelCase(self   :					Any       ,					_A   :					int       ,					_A   :					Optional[int]       ,					_A   :					str       ,					_A   :					Union[str, Any]       ,					_A   :					str       ,					_A   :					Dict       ,					_A   :					Tuple       ,					)		->		List[str]:
         snake_case				  =      LiltModel(config=A_     )
         model.to(A_     )
         model.eval()
         snake_case				  =      model(A_       ,					bbox=A_       ,					attention_mask=A_       ,					token_type_ids=A_     )
         snake_case				  =      model(A_       ,					bbox=A_       ,					token_type_ids=A_     )
         snake_case				  =      model(A_       ,					bbox=A_     )

         self.parent.assertEqual(result.last_hidden_state.shape       ,					(self.batch_size, self.seq_length, self.hidden_size)     )
         self.parent.assertEqual(result.pooler_output.shape       ,					(self.batch_size, self.hidden_size)     )





     def 	UpperCAmelCase(self   :					str       ,					_A   :					Dict       ,					_A   :					Union[str, Any]       ,					_A   :					Tuple       ,					_A   :					Dict       ,					_A   :					List[str]       ,					_A   :					Dict       ,					_A   :					int       ,					)		->		Optional[Any]:
         snake_case				  =      self.num_labels
         snake_case				  =      LiltForTokenClassification(config=A_     )
         model.to(A_     )
         model.eval()
         snake_case				  =      model(
             A_       ,					bbox=A_       ,					attention_mask=A_       ,					token_type_ids=A_       ,					labels=A_     )
         self.parent.assertEqual(result.logits.shape       ,					(self.batch_size, self.seq_length, self.num_labels)     )





     def 	UpperCAmelCase(self   :					int       ,					_A   :					List[str]       ,					_A   :					Dict       ,					_A   :					Optional[int]       ,					_A   :					Optional[int]       ,					_A   :					Any       ,					_A   :					Dict       ,					_A   :					Dict       ,					)		->		List[Any]:
         snake_case				  =      LiltForQuestionAnswering(config=A_     )
         model.to(A_     )
         model.eval()
         snake_case				  =      model(
             A_       ,					bbox=A_       ,					attention_mask=A_       ,					token_type_ids=A_       ,					start_positions=A_       ,					end_positions=A_       ,					)
         self.parent.assertEqual(result.start_logits.shape       ,					(self.batch_size, self.seq_length)     )
         self.parent.assertEqual(result.end_logits.shape       ,					(self.batch_size, self.seq_length)     )





     def 	UpperCAmelCase(self   :					int     )		->		List[Any]:
         snake_case				  =      self.prepare_config_and_inputs()
         (
             (
             snake_case      
         )  ,							(
             snake_case      
         )  ,							(
             snake_case      
         )  ,							(
             snake_case      
         )  ,							(
             snake_case      
         )  ,							(
             snake_case      
         )  ,							(
             snake_case      
         )  ,							      
         )				  =      config_and_inputs
         snake_case				  =      {
             "input_ids": input_ids,
             "bbox": bbox,
             "token_type_ids": token_type_ids,
             "attention_mask": input_mask,
         }
         return config, inputs_dict







@require_torch
class   lowerCamelCase	(						_lowercase							,				_lowercase							,				_lowercase							,				unittest.TestCase						):
     UpperCAmelCase__       :							Union[str, Any]     =	(
         (
             LiltModel,
             LiltForSequenceClassification,
             LiltForTokenClassification,
             LiltForQuestionAnswering,
         )
         if is_torch_available()
         else ()
     )
     UpperCAmelCase__       :							str     =	(
         {
             '''feature-extraction''': LiltModel,
             '''question-answering''': LiltForQuestionAnswering,
             '''text-classification''': LiltForSequenceClassification,
             '''token-classification''': LiltForTokenClassification,
             '''zero-shot''': LiltForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     UpperCAmelCase__       :							Optional[Any]     =	False
     UpperCAmelCase__       :							List[str]     =	False





     def 	UpperCAmelCase(self   :					Any       ,					_A   :					List[Any]       ,					_A   :					Optional[Any]       ,					_A   :					Any       ,					_A   :					Dict       ,					_A   :					Union[str, Any]     )		->		int:
         return True





     def 	UpperCAmelCase(self   :					int     )		->		Optional[int]:
         snake_case				  =      LiltModelTester(self     )
         snake_case				  =      ConfigTester(self       ,					config_class=A_       ,					hidden_size=3_7     )





     def 	UpperCAmelCase(self   :					Any     )		->		Optional[int]:
         self.config_tester.run_common_tests()





     def 	UpperCAmelCase(self   :					Any     )		->		Any:
         snake_case				  =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A_     )





     def 	UpperCAmelCase(self   :					List[str]     )		->		Tuple:
         snake_case				  =      self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
             snake_case				  =      type
             self.model_tester.create_and_check_model(*A_     )





     def 	UpperCAmelCase(self   :					Union[str, Any]     )		->		List[Any]:
         snake_case				  =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*A_     )





     def 	UpperCAmelCase(self   :					List[str]     )		->		Any:
         snake_case				  =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*A_     )





     @slow
     def 	UpperCAmelCase(self   :					List[Any]     )		->		List[Any]:
         for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             snake_case				  =      LiltModel.from_pretrained(A_     )
             self.assertIsNotNone(A_     )







@require_torch
@slow
class   lowerCamelCase	(						unittest.TestCase						):





     def 	UpperCAmelCase(self   :					int     )		->		int:
         snake_case				  =      LiltModel.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base"     ).to(A_     )

         snake_case				  =      torch.tensor([[1, 2]]       ,					device=A_     )
         snake_case				  =      torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]       ,					device=A_     )

         # forward pass
         with torch.no_grad():
             snake_case				  =      model(input_ids=A_       ,					bbox=A_     )

         snake_case				  =      torch.Size([1, 2, 7_6_8]     )
         snake_case				  =      torch.tensor(
             [[-0.06_53, 0.09_50, -0.00_61], [-0.05_45, 0.09_26, -0.03_24]]       ,					device=A_       ,					)

         self.assertTrue(outputs.last_hidden_state.shape       ,					A_     )
         self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3]       ,					A_       ,					atol=1E-3     )     )



import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetImgaImgPipeline,
    KandinskyVaaPriorEmbaEmbPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()







class   lowerCamelCase	(						A_							,				unittest.TestCase						):
     UpperCAmelCase__       :							Any     =	KandinskyVaaControlnetImgaImgPipeline
     UpperCAmelCase__       :							Optional[Any]     =	["image_embeds", "negative_image_embeds", "image", "hint"]
     UpperCAmelCase__       :							List[Any]     =	["image_embeds", "negative_image_embeds", "image", "hint"]
     UpperCAmelCase__       :							List[str]     =	[
         "generator",
         "height",
         "width",
         "strength",
         "guidance_scale",
         "num_inference_steps",
         "return_dict",
         "guidance_scale",
         "num_images_per_prompt",
         "output_type",
         "return_dict",
     ]
     UpperCAmelCase__       :							List[str]     =	False





     @property
     def 	UpperCAmelCase(self   :					Optional[int]     )		->		Dict:
         return 3_2





     @property
     def 	UpperCAmelCase(self   :					Union[str, Any]     )		->		Optional[int]:
         return 3_2





     @property
     def 	UpperCAmelCase(self   :					Optional[Any]     )		->		Union[str, Any]:
         return self.time_input_dim





     @property
     def 	UpperCAmelCase(self   :					Union[str, Any]     )		->		Union[str, Any]:
         return self.time_input_dim * 4





     @property
     def 	UpperCAmelCase(self   :					Optional[Any]     )		->		int:
         return 1_0_0





     @property
     def 	UpperCAmelCase(self   :					int     )		->		Optional[Any]:
         torch.manual_seed(0     )

         snake_case				  =      {
             "in_channels": 8,
             # Out channels is double in channels because predicts mean and variance
             "out_channels": 8,
             "addition_embed_type": "image_hint",
             "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
             "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
             "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
             "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
             "layers_per_block": 1,
             "encoder_hid_dim": self.text_embedder_hidden_size,
             "encoder_hid_dim_type": "image_proj",
             "cross_attention_dim": self.cross_attention_dim,
             "attention_head_dim": 4,
             "resnet_time_scale_shift": "scale_shift",
             "class_embed_type": None,
         }

         snake_case				  =      UNetaDConditionModel(**_A     )
         return model





     @property
     def 	UpperCAmelCase(self   :					Any     )		->		List[str]:
         return {
             "block_out_channels": [3_2, 3_2, 6_4, 6_4],
             "down_block_types": [
                 "DownEncoderBlock2D",
                 "DownEncoderBlock2D",
                 "DownEncoderBlock2D",
                 "AttnDownEncoderBlock2D",
             ],
             "in_channels": 3,
             "latent_channels": 4,
             "layers_per_block": 1,
             "norm_num_groups": 8,
             "norm_type": "spatial",
             "num_vq_embeddings": 1_2,
             "out_channels": 3,
             "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
             "vq_embed_dim": 4,
         }





     @property
     def 	UpperCAmelCase(self   :					Union[str, Any]     )		->		List[str]:
         torch.manual_seed(0     )
         snake_case				  =      VQModel(**self.dummy_movq_kwargs     )
         return model





     def 	UpperCAmelCase(self   :					Any     )		->		Optional[Any]:
         snake_case				  =      self.dummy_unet
         snake_case				  =      self.dummy_movq

         snake_case				  =      {
             "num_train_timesteps": 1_0_0_0,
             "beta_schedule": "linear",
             "beta_start": 0.0_00_85,
             "beta_end": 0.0_12,
             "clip_sample": False,
             "set_alpha_to_one": False,
             "steps_offset": 0,
             "prediction_type": "epsilon",
             "thresholding": False,
         }

         snake_case				  =      DDIMScheduler(**_A     )

         snake_case				  =      {
             "unet": unet,
             "scheduler": scheduler,
             "movq": movq,
         }

         return components





     def 	UpperCAmelCase(self   :					Any       ,					_A   :					Any       ,					_A   :					Optional[Any]=0     )		->		List[Any]:
         snake_case				  =      floats_tensor((1, self.text_embedder_hidden_size)       ,					rng=random.Random(_A     )     ).to(_A     )
         snake_case				  =      floats_tensor((1, self.text_embedder_hidden_size)       ,					rng=random.Random(seed + 1     )     ).to(
             _A     )
         # create init_image
         snake_case				  =      floats_tensor((1, 3, 6_4, 6_4)       ,					rng=random.Random(_A     )     ).to(_A     )
         snake_case				  =      image.cpu().permute(0       ,					2       ,					3       ,					1     )[0]
         snake_case				  =      Image.fromarray(np.uinta(_A     )     ).convert("RGB"     ).resize((2_5_6, 2_5_6)     )
         # create hint
         snake_case				  =      floats_tensor((1, 3, 6_4, 6_4)       ,					rng=random.Random(_A     )     ).to(_A     )

         if str(_A     ).startswith("mps"     ):
             snake_case				  =      torch.manual_seed(_A     )
         else:
             snake_case				  =      torch.Generator(device=_A     ).manual_seed(_A     )
         snake_case				  =      {
             "image": init_image,
             "image_embeds": image_embeds,
             "negative_image_embeds": negative_image_embeds,
             "hint": hint,
             "generator": generator,
             "height": 6_4,
             "width": 6_4,
             "num_inference_steps": 1_0,
             "guidance_scale": 7.0,
             "strength": 0.2,
             "output_type": "np",
         }
         return inputs





     def 	UpperCAmelCase(self   :					str     )		->		Union[str, Any]:
         snake_case				  =      "cpu"

         snake_case				  =      self.get_dummy_components()

         snake_case				  =      self.pipeline_class(**_A     )
         snake_case				  =      pipe.to(_A     )

         pipe.set_progress_bar_config(disable=_A     )

         snake_case				  =      pipe(**self.get_dummy_inputs(_A     )     )
         snake_case				  =      output.images

         snake_case				  =      pipe(
             **self.get_dummy_inputs(_A     )       ,					return_dict=_A       ,					)[0]

         snake_case				  =      image[0, -3:, -3:, -1]
         snake_case				  =      image_from_tuple[0, -3:, -3:, -1]

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

         snake_case				  =      np.array(
             [0.54_98_50_34, 0.55_50_93_65, 0.52_56_15_04, 0.5_57_04_94, 0.5_59_38_18, 0.5_26_39_79, 0.50_28_56_43, 0.5_06_98_46, 0.51_19_67_36]     )
         assert (
             np.abs(image_slice.flatten() - expected_slice     ).max() < 1E-2
         ), f' expected_slice {expected_slice}, but got {image_slice.flatten()}'
         assert (
             np.abs(image_from_tuple_slice.flatten() - expected_slice     ).max() < 1E-2
         ), f' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'







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





     def 	UpperCAmelCase(self   :					int     )		->		Optional[int]:
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()





     def 	UpperCAmelCase(self   :					int     )		->		Tuple:
         snake_case				  =      load_numpy(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
             "/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy"     )

         snake_case				  =      load_image(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"     )
         snake_case				  =      init_image.resize((5_1_2, 5_1_2)     )

         snake_case				  =      load_image(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
             "/kandinskyv22/hint_image_cat.png"     )
         snake_case				  =      torch.from_numpy(np.array(_A     )     ).float() / 2_55.0
         snake_case				  =      hint.permute(2       ,					0       ,					1     ).unsqueeze(0     )

         snake_case				  =      "A robot, 4k photo"

         snake_case				  =      KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
             "kandinsky-community/kandinsky-2-2-prior"       ,					torch_dtype=torch.floataa     )
         pipe_prior.to(_A     )

         snake_case				  =      KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
             "kandinsky-community/kandinsky-2-2-controlnet-depth"       ,					torch_dtype=torch.floataa     )
         snake_case				  =      pipeline.to(_A     )

         pipeline.set_progress_bar_config(disable=_A     )

         snake_case				  =      torch.Generator(device="cpu"     ).manual_seed(0     )

         snake_case  ,							snake_case				  =      pipe_prior(
             _A       ,					image=_A       ,					strength=0.85       ,					generator=_A       ,					negative_prompt=""       ,					).to_tuple()

         snake_case				  =      pipeline(
             image=_A       ,					image_embeds=_A       ,					negative_image_embeds=_A       ,					hint=_A       ,					generator=_A       ,					num_inference_steps=1_0_0       ,					height=5_1_2       ,					width=5_1_2       ,					strength=0.5       ,					output_type="np"       ,					)

         snake_case				  =      output.images[0]

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

         assert_mean_pixel_difference(_A       ,					_A     )

