
'''simple docstring'''






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 			UpperCAmelCase__    (							A    ,						unittest.TestCase			):
    lowerCAmelCase_					     =		KandinskyVaaControlnetImgaImgPipeline
    lowerCAmelCase_					     =		['image_embeds', 'negative_image_embeds', 'image', 'hint']
    lowerCAmelCase_					     =		['image_embeds', 'negative_image_embeds', 'image', 'hint']
    lowerCAmelCase_					     =		[
        'generator',
        'height',
        'width',
        'strength',
        'guidance_scale',
        'num_inference_steps',
        'return_dict',
        'guidance_scale',
        'num_images_per_prompt',
        'output_type',
        'return_dict',
    ]
    lowerCAmelCase_					     =		False



    @property
    def 	lowerCamelCase_	(						self   :							Any  ):
          return 3_2



    @property
    def 	lowerCamelCase_	(						self   :							List[str]  ):
          return 3_2



    @property
    def 	lowerCamelCase_	(						self   :							Union[str, Any]  ):
          return self.time_input_dim



    @property
    def 	lowerCamelCase_	(						self   :							Any  ):
          return self.time_input_dim * 4



    @property
    def 	lowerCamelCase_	(						self   :							str  ):
          return 1_0_0



    @property
    def 	lowerCamelCase_	(						self   :							Optional[Any]  ):
          torch.manual_seed(0  )

          _lowerCamelCase					: Optional[int]		    = {
              "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,
          }

          _lowerCamelCase					: Any		    = UNetaDConditionModel(**__A  )
          return model



    @property
    def 	lowerCamelCase_	(						self   :							Any  ):
          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 	lowerCamelCase_	(						self   :							Optional[Any]  ):
          torch.manual_seed(0  )
          _lowerCamelCase					: List[Any]		    = VQModel(**self.dummy_movq_kwargs  )
          return model



    def 	lowerCamelCase_	(						self   :							Dict  ):
          _lowerCamelCase					: Any		    = self.dummy_unet
          _lowerCamelCase					: int		    = self.dummy_movq

          _lowerCamelCase					: Optional[int]		    = {
              "num_train_timesteps": 1_0_0_0,
              "beta_schedule": "linear",
              "beta_start": 0.00085,
              "beta_end": 0.012,
              "clip_sample": False,
              "set_alpha_to_one": False,
              "steps_offset": 0,
              "prediction_type": "epsilon",
              "thresholding": False,
          }

          _lowerCamelCase					: Optional[Any]		    = DDIMScheduler(**__A  )

          _lowerCamelCase					: Dict		    = {
              "unet": unet,
              "scheduler": scheduler,
              "movq": movq,
          }

          return components



    def 	lowerCamelCase_	(						self   :							Dict,__A   :							List[Any],__A   :							int=0  ):
          _lowerCamelCase					: List[str]		    = floats_tensor((1, self.text_embedder_hidden_size),rng=random.Random(__A  )  ).to(__A  )
          _lowerCamelCase					: Union[str, Any]		    = floats_tensor((1, self.text_embedder_hidden_size),rng=random.Random(seed + 1  )  ).to(
              __A  )
          # create init_image
          _lowerCamelCase					: Any		    = floats_tensor((1, 3, 6_4, 6_4),rng=random.Random(__A  )  ).to(__A  )
          _lowerCamelCase					: Optional[Any]		    = image.cpu().permute(0,2,3,1  )[0]
          _lowerCamelCase					: List[Any]		    = Image.fromarray(np.uinta(__A  )  ).convert("RGB"  ).resize((2_5_6, 2_5_6)  )
          # create hint
          _lowerCamelCase					: str		    = floats_tensor((1, 3, 6_4, 6_4),rng=random.Random(__A  )  ).to(__A  )

          if str(__A  ).startswith("mps"  ):
                _lowerCamelCase					: int		    = torch.manual_seed(__A  )
          else:
                _lowerCamelCase					: Union[str, Any]		    = torch.Generator(device=__A  ).manual_seed(__A  )
          _lowerCamelCase					: Optional[Any]		    = {
              "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 	lowerCamelCase_	(						self   :							Tuple  ):
          _lowerCamelCase					: Optional[int]		    = "cpu"

          _lowerCamelCase					: List[Any]		    = self.get_dummy_components()

          _lowerCamelCase					: Any		    = self.pipeline_class(**__A  )
          _lowerCamelCase					: Optional[int]		    = pipe.to(__A  )

          pipe.set_progress_bar_config(disable=__A  )

          _lowerCamelCase					: Optional[Any]		    = pipe(**self.get_dummy_inputs(__A  )  )
          _lowerCamelCase					: List[Any]		    = output.images

          _lowerCamelCase					: Optional[Any]		    = pipe(
              **self.get_dummy_inputs(__A  ),return_dict=__A,)[0]

          _lowerCamelCase					: Optional[Any]		    = image[0, -3:, -3:, -1]
          _lowerCamelCase					: int		    = image_from_tuple[0, -3:, -3:, -1]

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

          _lowerCamelCase					: Any		    = np.array(
              [0.54985034, 0.55509365, 0.52561504, 0.5570494, 0.5593818, 0.5263979, 0.50285643, 0.5069846, 0.51196736]  )
          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 			UpperCAmelCase__    (							unittest.TestCase			):



    def 	lowerCamelCase_	(						self   :							Tuple  ):
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()



    def 	lowerCamelCase_	(						self   :							List[str]  ):
          _lowerCamelCase					: List[str]		    = load_numpy(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
              "/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy"  )

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

          _lowerCamelCase					: Any		    = load_image(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
              "/kandinskyv22/hint_image_cat.png"  )
          _lowerCamelCase					: List[str]		    = torch.from_numpy(np.array(__A  )  ).float() / 255.0
          _lowerCamelCase					: Union[str, Any]		    = hint.permute(2,0,1  ).unsqueeze(0  )

          _lowerCamelCase					: int		    = "A robot, 4k photo"

          _lowerCamelCase					: Optional[Any]		    = KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
              "kandinsky-community/kandinsky-2-2-prior",torch_dtype=torch.floataa  )
          pipe_prior.to(__A  )

          _lowerCamelCase					: str		    = KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
              "kandinsky-community/kandinsky-2-2-controlnet-depth",torch_dtype=torch.floataa  )
          _lowerCamelCase					: Optional[int]		    = pipeline.to(__A  )

          pipeline.set_progress_bar_config(disable=__A  )

          _lowerCamelCase					: Optional[Any]		    = torch.Generator(device="cpu"  ).manual_seed(0  )

          _lowerCamelCase    ,		_lowerCamelCase					: List[Any]		    = pipe_prior(
              __A,image=__A,strength=0.85,generator=__A,negative_prompt="",).to_tuple()

          _lowerCamelCase					: Any		    = 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",)

          _lowerCamelCase					: List[Any]		    = output.images[0]

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

          assert_mean_pixel_difference(__A,__A  )






import unittest

from transformers import SqueezeBertConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        SqueezeBertForMaskedLM,
        SqueezeBertForMultipleChoice,
        SqueezeBertForQuestionAnswering,
        SqueezeBertForSequenceClassification,
        SqueezeBertForTokenClassification,
        SqueezeBertModel,
    )

class   lowerCAmelCase				(   __UpperCamelCase     ):
 def __init__( self    : str     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : Dict=13     ,	UpperCAmelCase    : List[Any]=7     ,	UpperCAmelCase    : Tuple=True     ,	UpperCAmelCase    : str=True     ,	UpperCAmelCase    : int=False     ,	UpperCAmelCase    : Optional[Any]=True     ,	UpperCAmelCase    : int=99     ,	UpperCAmelCase    : Dict=32     ,	UpperCAmelCase    : Dict=5     ,	UpperCAmelCase    : List[str]=4     ,	UpperCAmelCase    : Optional[Any]=64     ,	UpperCAmelCase    : Any="gelu"     ,	UpperCAmelCase    : List[str]=0.1     ,	UpperCAmelCase    : Optional[Any]=0.1     ,	UpperCAmelCase    : Any=512     ,	UpperCAmelCase    : List[str]=16     ,	UpperCAmelCase    : Union[str, Any]=2     ,	UpperCAmelCase    : Union[str, Any]=0.0_2     ,	UpperCAmelCase    : Dict=3     ,	UpperCAmelCase    : List[Any]=4     ,	UpperCAmelCase    : int=None     ,	UpperCAmelCase    : Optional[int]=2     ,	UpperCAmelCase    : Tuple=2     ,	UpperCAmelCase    : Optional[Any]=2     ,	UpperCAmelCase    : Tuple=2     ,	UpperCAmelCase    : List[str]=4     ,	UpperCAmelCase    : Dict=1     ,	)     ->      List[Any]:
     lowerCamelCase__       : Any   					=						parent
     lowerCamelCase__       : Tuple   					=						batch_size
     lowerCamelCase__       : Union[str, Any]   					=						seq_length
     lowerCamelCase__       : Optional[Any]   					=						is_training
     lowerCamelCase__       : Optional[Any]   					=						use_input_mask
     lowerCamelCase__       : List[Any]   					=						use_token_type_ids
     lowerCamelCase__       : str   					=						use_labels
     lowerCamelCase__       : Any   					=						vocab_size
     lowerCamelCase__       : Any   					=						hidden_size
     lowerCamelCase__       : int   					=						num_hidden_layers
     lowerCamelCase__       : Optional[Any]   					=						num_attention_heads
     lowerCamelCase__       : Optional[int]   					=						intermediate_size
     lowerCamelCase__       : int   					=						hidden_act
     lowerCamelCase__       : List[Any]   					=						hidden_dropout_prob
     lowerCamelCase__       : List[str]   					=						attention_probs_dropout_prob
     lowerCamelCase__       : Any   					=						max_position_embeddings
     lowerCamelCase__       : Dict   					=						type_vocab_size
     lowerCamelCase__       : Optional[int]   					=						type_sequence_label_size
     lowerCamelCase__       : Any   					=						initializer_range
     lowerCamelCase__       : int   					=						num_labels
     lowerCamelCase__       : Tuple   					=						num_choices
     lowerCamelCase__       : Optional[Any]   					=						scope
     lowerCamelCase__       : Dict   					=						q_groups
     lowerCamelCase__       : Optional[Any]   					=						k_groups
     lowerCamelCase__       : Any   					=						v_groups
     lowerCamelCase__       : List[str]   					=						post_attention_groups
     lowerCamelCase__       : Dict   					=						intermediate_groups
     lowerCamelCase__       : Optional[int]   					=						output_groups
 def 	A_      ( self    : str      )     ->      str:
     lowerCamelCase__       : List[Any]   					=						ids_tensor([self.batch_size, self.seq_length]     ,	self.vocab_size      )

     lowerCamelCase__       : Tuple   					=						None
     if self.use_input_mask:
         lowerCamelCase__       : Any   					=						random_attention_mask([self.batch_size, self.seq_length]      )

     lowerCamelCase__       : Optional[Any]   					=						None
     lowerCamelCase__       : Union[str, Any]   					=						None
     lowerCamelCase__       : Dict   					=						None
     if self.use_labels:
         lowerCamelCase__       : Optional[int]   					=						ids_tensor([self.batch_size]     ,	self.type_sequence_label_size      )
         lowerCamelCase__       : Union[str, Any]   					=						ids_tensor([self.batch_size, self.seq_length]     ,	self.num_labels      )
         lowerCamelCase__       : List[str]   					=						ids_tensor([self.batch_size]     ,	self.num_choices      )

     lowerCamelCase__       : int   					=						self.get_config()

     return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
 def 	A_      ( self    : Union[str, Any]      )     ->      List[Any]:
     return SqueezeBertConfig(
         embedding_size=self.hidden_size     ,	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     ,	attention_probs_dropout_prob=self.hidden_dropout_prob     ,	attention_dropout=self.attention_probs_dropout_prob     ,	max_position_embeddings=self.max_position_embeddings     ,	initializer_range=self.initializer_range     ,	q_groups=self.q_groups     ,	k_groups=self.k_groups     ,	v_groups=self.v_groups     ,	post_attention_groups=self.post_attention_groups     ,	intermediate_groups=self.intermediate_groups     ,	output_groups=self.output_groups     ,	)
 def 	A_      ( self    : List[Any]     ,	UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : str     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : Any     ,	UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : List[str]      )     ->      List[str]:
     lowerCamelCase__       : List[Any]   					=						SqueezeBertModel(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : Optional[Any]   					=						model(UpperCAmelCase     ,	UpperCAmelCase      )
     lowerCamelCase__       : Union[str, Any]   					=						model(UpperCAmelCase      )
     self.parent.assertEqual(result.last_hidden_state.shape     ,	(self.batch_size, self.seq_length, self.hidden_size)      )
 def 	A_      ( self    : List[str]     ,	UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : Tuple     ,	UpperCAmelCase    : List[str]     ,	UpperCAmelCase    : List[str]     ,	UpperCAmelCase    : Union[str, Any]     ,	UpperCAmelCase    : List[Any]      )     ->      Optional[Any]:
     lowerCamelCase__       : List[Any]   					=						SqueezeBertForMaskedLM(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : Union[str, Any]   					=						model(UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	labels=UpperCAmelCase      )
     self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.seq_length, self.vocab_size)      )
 def 	A_      ( self    : int     ,	UpperCAmelCase    : Optional[int]     ,	UpperCAmelCase    : List[str]     ,	UpperCAmelCase    : int     ,	UpperCAmelCase    : List[Any]     ,	UpperCAmelCase    : Union[str, Any]     ,	UpperCAmelCase    : List[str]      )     ->      Optional[Any]:
     lowerCamelCase__       : Union[str, Any]   					=						SqueezeBertForQuestionAnswering(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : List[Any]   					=						model(
         UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	start_positions=UpperCAmelCase     ,	end_positions=UpperCAmelCase      )
     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 	A_      ( self    : Tuple     ,	UpperCAmelCase    : str     ,	UpperCAmelCase    : Optional[int]     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : Any     ,	UpperCAmelCase    : Any      )     ->      Any:
     lowerCamelCase__       : int   					=						self.num_labels
     lowerCamelCase__       : Optional[int]   					=						SqueezeBertForSequenceClassification(UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : Union[str, Any]   					=						model(UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	labels=UpperCAmelCase      )
     self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.num_labels)      )
 def 	A_      ( self    : int     ,	UpperCAmelCase    : Any     ,	UpperCAmelCase    : Tuple     ,	UpperCAmelCase    : Any     ,	UpperCAmelCase    : List[str]     ,	UpperCAmelCase    : List[Any]     ,	UpperCAmelCase    : Optional[Any]      )     ->      List[str]:
     lowerCamelCase__       : str   					=						self.num_labels
     lowerCamelCase__       : int   					=						SqueezeBertForTokenClassification(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()

     lowerCamelCase__       : List[Any]   					=						model(UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	labels=UpperCAmelCase      )
     self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.seq_length, self.num_labels)      )
 def 	A_      ( self    : Optional[int]     ,	UpperCAmelCase    : int     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : List[Any]     ,	UpperCAmelCase    : str     ,	UpperCAmelCase    : int      )     ->      Tuple:
     lowerCamelCase__       : Optional[int]   					=						self.num_choices
     lowerCamelCase__       : List[str]   					=						SqueezeBertForMultipleChoice(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : Dict   					=						input_ids.unsqueeze(1      ).expand(-1     ,	self.num_choices     ,	-1      ).contiguous()
     lowerCamelCase__       : List[str]   					=						input_mask.unsqueeze(1      ).expand(-1     ,	self.num_choices     ,	-1      ).contiguous()
     lowerCamelCase__       : str   					=						model(
         UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	labels=UpperCAmelCase     ,	)
     self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.num_choices)      )







 def 	A_      ( self    : Optional[Any]      )     ->      Optional[int]:
     lowerCamelCase__       : Optional[Any]   					=						self.prepare_config_and_inputs()
     ((lowerCamelCase__)					,				(lowerCamelCase__)					,				(lowerCamelCase__)					,				(lowerCamelCase__)					,				(lowerCamelCase__)					,				(lowerCamelCase__))       : Tuple   					=						config_and_inputs
     lowerCamelCase__       : Optional[Any]   					=						{'input_ids': input_ids, 'attention_mask': input_mask}
     return config, inputs_dict


@require_torch
class   lowerCAmelCase				(   __UpperCamelCase,    __UpperCamelCase,    unittest.TestCase     ):
 UpperCAmelCase__						=						(
     (
         SqueezeBertModel,
         SqueezeBertForMaskedLM,
         SqueezeBertForMultipleChoice,
         SqueezeBertForQuestionAnswering,
         SqueezeBertForSequenceClassification,
         SqueezeBertForTokenClassification,
     )
     if is_torch_available()
     else None
 )
 UpperCAmelCase__						=						(
     {
         """feature-extraction""": SqueezeBertModel,
         """fill-mask""": SqueezeBertForMaskedLM,
         """question-answering""": SqueezeBertForQuestionAnswering,
         """text-classification""": SqueezeBertForSequenceClassification,
         """token-classification""": SqueezeBertForTokenClassification,
         """zero-shot""": SqueezeBertForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 UpperCAmelCase__						=						False
 UpperCAmelCase__						=						True
 UpperCAmelCase__						=						False
 def 	A_      ( self    : Union[str, Any]      )     ->      Dict:
     lowerCamelCase__       : Optional[Any]   					=						SqueezeBertModelTester(self      )
     lowerCamelCase__       : Optional[Any]   					=						ConfigTester(self     ,	config_class=UpperCAmelCase     ,	dim=37      )
 def 	A_      ( self    : str      )     ->      str:
     self.config_tester.run_common_tests()
 def 	A_      ( self    : str      )     ->      int:
     lowerCamelCase__       : List[str]   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_model(*UpperCAmelCase      )
 def 	A_      ( self    : Union[str, Any]      )     ->      Tuple:
     lowerCamelCase__       : int   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_masked_lm(*UpperCAmelCase      )
 def 	A_      ( self    : Union[str, Any]      )     ->      Any:
     lowerCamelCase__       : List[str]   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_question_answering(*UpperCAmelCase      )
 def 	A_      ( self    : Union[str, Any]      )     ->      List[str]:
     lowerCamelCase__       : Optional[Any]   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_sequence_classification(*UpperCAmelCase      )
 def 	A_      ( self    : Optional[int]      )     ->      Optional[Any]:
     lowerCamelCase__       : Tuple   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_token_classification(*UpperCAmelCase      )
 def 	A_      ( self    : Any      )     ->      Optional[Any]:
     lowerCamelCase__       : List[str]   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_multiple_choice(*UpperCAmelCase      )







 @slow
 def 	A_      ( self    : Optional[int]      )     ->      Dict:
     for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         lowerCamelCase__       : Any   					=						SqueezeBertModel.from_pretrained(UpperCAmelCase      )
         self.assertIsNotNone(UpperCAmelCase      )


@require_sentencepiece
@require_tokenizers
@require_torch
class   lowerCAmelCase				(   unittest.TestCase     ):
 @slow
 def 	A_      ( self    : Optional[Any]      )     ->      List[str]:
     lowerCamelCase__       : Dict   					=						SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli'      )

     lowerCamelCase__       : Optional[int]   					=						torch.tensor([[1, 29414, 232, 328, 740, 1140, 12695, 69, 13, 1588, 2]]      )
     lowerCamelCase__       : Optional[int]   					=						model(UpperCAmelCase      )[0]
     lowerCamelCase__       : Dict   					=						torch.Size((1, 3)      )
     self.assertEqual(output.shape     ,	UpperCAmelCase      )
     lowerCamelCase__       : List[str]   					=						torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]      )
     self.assertTrue(torch.allclose(UpperCAmelCase     ,	UpperCAmelCase     ,	atol=1e-4      )      )





