






"""simple docstring"""





import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import MaskaFormerConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel

  if is_vision_available():
    from transformers import MaskaFormerImageProcessor

if is_vision_available():
  from PIL import Image
class    __lowerCamelCase    :

   def __init__(					self ,				snake_case_ ,				snake_case_=2 ,				snake_case_=True ,				snake_case_=False ,				snake_case_=10 ,				snake_case_=3 ,				snake_case_=32 * 8 ,				snake_case_=32 * 8 ,				snake_case_=4 ,				snake_case_=64 ,				)		->       Dict:
       UpperCamelCase__         =    parent
       UpperCamelCase__         =    batch_size
       UpperCamelCase__         =    is_training
       UpperCamelCase__         =    use_auxiliary_loss
       UpperCamelCase__         =    num_queries
       UpperCamelCase__         =    num_channels
       UpperCamelCase__         =    min_size
       UpperCamelCase__         =    max_size
       UpperCamelCase__         =    num_labels
       UpperCamelCase__         =    hidden_dim
       UpperCamelCase__         =    hidden_dim

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]      ).to(
           snake_case_      )

       UpperCamelCase__         =    torch.ones([self.batch_size, self.min_size, self.max_size] ,				device=snake_case_      )

       UpperCamelCase__         =    (
           torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] ,				device=snake_case_      ) > 0.5
       ).float()
       UpperCamelCase__         =    (torch.rand((self.batch_size, self.num_labels) ,				device=snake_case_      ) > 0.5).long()

       UpperCamelCase__         =    self.get_config()
       return config, pixel_values, pixel_mask, mask_labels, class_labels

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__         =    MaskaFormerConfig(
           hidden_size=self.hidden_dim ,				)
       UpperCamelCase__         =    self.num_queries
       UpperCamelCase__         =    self.num_labels

       UpperCamelCase__         =    [1, 1, 1, 1]
       UpperCamelCase__         =    self.num_channels

       UpperCamelCase__         =    64
       UpperCamelCase__         =    128
       UpperCamelCase__         =    self.hidden_dim
       UpperCamelCase__         =    self.hidden_dim
       UpperCamelCase__         =    self.hidden_dim
       return config

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__         =    self.prepare_config_and_inputs()
       UpperCamelCase__         =    {'pixel_values': pixel_values, 'pixel_mask': pixel_mask}
       return config, inputs_dict

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_      )		->       Tuple:
       UpperCamelCase__         =    output.encoder_hidden_states
       UpperCamelCase__         =    output.pixel_decoder_hidden_states
       UpperCamelCase__         =    output.transformer_decoder_hidden_states

       self.parent.assertTrue(len(snake_case_      ) ,				len(config.backbone_config.depths      )      )
       self.parent.assertTrue(len(snake_case_      ) ,				len(config.backbone_config.depths      )      )
       self.parent.assertTrue(len(snake_case_      ) ,				config.decoder_layers      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_=False      )		->       List[str]:
       with torch.no_grad():
           UpperCamelCase__         =    MaskaFormerModel(config=snake_case_      )
           model.to(snake_case_      )
           model.eval()

           UpperCamelCase__         =    model(pixel_values=snake_case_ ,				pixel_mask=snake_case_      )
           UpperCamelCase__         =    model(snake_case_ ,				output_hidden_states=snake_case_      )

       self.parent.assertEqual(
           output.transformer_decoder_last_hidden_state.shape ,				(self.batch_size, self.num_queries, self.hidden_dim) ,				)
       # let's ensure the other two hidden state exists
       self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None      )
       self.parent.assertTrue(output.encoder_last_hidden_state is not None      )

       if output_hidden_states:
           self.check_output_hidden_state(snake_case_ ,				snake_case_      )







   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[Any]:
       UpperCamelCase__         =    MaskaFormerForUniversalSegmentation(config=snake_case_      )
       model.to(snake_case_      )
       model.eval()

       def comm_check_on_output(snake_case_      ):
           # let's still check that all the required stuff is there
           self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None      )
           self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None      )
           self.parent.assertTrue(result.encoder_last_hidden_state is not None      )
           # okay, now we need to check the logits shape
           # due to the encoder compression, masks have a //4 spatial size
           self.parent.assertEqual(
               result.masks_queries_logits.shape ,				(self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) ,				)
           # + 1 for null class
           self.parent.assertEqual(
               result.class_queries_logits.shape ,				(self.batch_size, self.num_queries, self.num_labels + 1)      )

       with torch.no_grad():
           UpperCamelCase__         =    model(pixel_values=snake_case_ ,				pixel_mask=snake_case_      )
           UpperCamelCase__         =    model(snake_case_      )

           comm_check_on_output(snake_case_      )

           UpperCamelCase__         =    model(
               pixel_values=snake_case_ ,				pixel_mask=snake_case_ ,				mask_labels=snake_case_ ,				class_labels=snake_case_      )

       comm_check_on_output(snake_case_      )

       self.parent.assertTrue(result.loss is not None      )
       self.parent.assertEqual(result.loss.shape ,				torch.Size([1]      )      )







@require_torch
class    __lowerCamelCase    (  _a							,	_a							,	unittest.TestCase  ):
   a      :				Any 						=(MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
   a      :				List[Any] 						={"""feature-extraction""": MaskaFormerModel} if is_torch_available() else {}

   a      :				List[Any] 						=False
   a      :				Optional[int] 						=False
   a      :				int 						=False
   a      :				Union[str, Any] 						=False

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    MaskaFormerModelTester(self      )
       UpperCamelCase__         =    ConfigTester(self ,				config_class=snake_case_ ,				has_text_modality=snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       self.config_tester.run_common_tests()

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.create_and_check_maskaformer_model(snake_case_ ,				**snake_case_ ,				output_hidden_states=snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*snake_case_      )

   @unittest.skip(reason='Mask2Former does not use inputs_embeds'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       pass

   @unittest.skip(reason='Mask2Former does not have a get_input_embeddings method'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       pass

   @unittest.skip(reason='Mask2Former is not a generative model'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       pass

   @unittest.skip(reason='Mask2Former does not use token embeddings'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       pass

   @require_torch_multi_gpu
   @unittest.skip(
       reason='Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[str]:
       pass

   @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       pass

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    inspect.signature(model.forward      )
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           UpperCamelCase__         =    [*signature.parameters.keys()]

           UpperCamelCase__         =    ['pixel_values']
           self.assertListEqual(arg_names[:1] ,				snake_case_      )

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
           UpperCamelCase__         =    MaskaFormerModel.from_pretrained(snake_case_      )
           self.assertIsNotNone(snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       UpperCamelCase__         =    (self.model_tester.min_size,) * 2
       UpperCamelCase__         =    {
           'pixel_values': torch.randn((2, 3, *size) ,				device=snake_case_      ),
           'mask_labels': torch.randn((2, 10, *size) ,				device=snake_case_      ),
           'class_labels': torch.zeros(2 ,				10 ,				device=snake_case_      ).long(),
       }
       UpperCamelCase__         =    self.model_tester.get_config()

       UpperCamelCase__         =    MaskaFormerForUniversalSegmentation(snake_case_      ).to(snake_case_      )
       UpperCamelCase__         =    model(**snake_case_      )
       self.assertTrue(outputs.loss is not None      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[Any]:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.create_and_check_maskaformer_model(snake_case_ ,				**snake_case_ ,				output_hidden_states=snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    model_class(snake_case_      ).to(snake_case_      )
           UpperCamelCase__         =    model(**snake_case_ ,				output_attentions=snake_case_      )
           self.assertTrue(outputs.attentions is not None      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       if not self.model_tester.is_training:
           return

       UpperCamelCase__         =    self.all_model_classes[1]
       UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()

       UpperCamelCase__         =    model_class(snake_case_      )
       model.to(snake_case_      )
       model.train()

       UpperCamelCase__         =    model(snake_case_ ,				mask_labels=snake_case_ ,				class_labels=snake_case_      ).loss
       loss.backward()







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__         =    self.all_model_classes[1]
       UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True

       UpperCamelCase__         =    model_class(snake_case_      ).to(snake_case_      )
       model.train()

       UpperCamelCase__         =    model(snake_case_ ,				mask_labels=snake_case_ ,				class_labels=snake_case_      )

       UpperCamelCase__         =    outputs.encoder_hidden_states[0]
       encoder_hidden_states.retain_grad()

       UpperCamelCase__         =    outputs.pixel_decoder_hidden_states[0]
       pixel_decoder_hidden_states.retain_grad()

       UpperCamelCase__         =    outputs.transformer_decoder_hidden_states[0]
       transformer_decoder_hidden_states.retain_grad()

       UpperCamelCase__         =    outputs.attentions[0]
       attentions.retain_grad()

       outputs.loss.backward(retain_graph=snake_case_      )

       self.assertIsNotNone(encoder_hidden_states.grad      )
       self.assertIsNotNone(pixel_decoder_hidden_states.grad      )
       self.assertIsNotNone(transformer_decoder_hidden_states.grad      )
       self.assertIsNotNone(attentions.grad      )







A__					: List[str]=	1E-4







def   lowerCAmelCase_( )					->	List[str]:
    """simple docstring"""

    UpperCamelCase__         =    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
    return image





@require_vision
@slow
class    __lowerCamelCase    (  unittest.TestCase  ):

   @cached_property
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       return "facebook/mask2former-swin-small-coco-instance"

   @cached_property
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints      ) if is_vision_available() else None

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    MaskaFormerModel.from_pretrained(self.model_checkpoints      ).to(snake_case_      )
       UpperCamelCase__         =    self.default_image_processor
       UpperCamelCase__         =    prepare_img()
       UpperCamelCase__         =    image_processor(snake_case_ ,				return_tensors='pt'      ).to(snake_case_      )
       UpperCamelCase__         =    inputs['pixel_values'].shape
       # check size is divisible by 32
       self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0      )
       # check size
       self.assertEqual(snake_case_ ,				(1, 3, 384, 384)      )

       with torch.no_grad():
           UpperCamelCase__         =    model(**snake_case_      )

       UpperCamelCase__         =    torch.tensor(
           [[-0.2_790, -1.0_717, -1.1_668], [-0.5_128, -0.3_128, -0.4_987], [-0.5_832, 0.1_971, -0.0_197]]      ).to(snake_case_      )
       self.assertTrue(
           torch.allclose(
               outputs.encoder_last_hidden_state[0, 0, :3, :3] ,				snake_case_ ,				atol=snake_case_      )      )

       UpperCamelCase__         =    torch.tensor(
           [[0.8_973, 1.1_847, 1.1_776], [1.1_934, 1.5_040, 1.5_128], [1.1_153, 1.4_486, 1.4_951]]      ).to(snake_case_      )
       self.assertTrue(
           torch.allclose(
               outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] ,				snake_case_ ,				atol=snake_case_      )      )

       UpperCamelCase__         =    torch.tensor(
           [[2.1_152, 1.7_000, -0.8_603], [1.5_808, 1.8_004, -0.9_353], [1.6_043, 1.7_495, -0.5_999]]      ).to(snake_case_      )
       self.assertTrue(
           torch.allclose(
               outputs.transformer_decoder_last_hidden_state[0, :3, :3] ,				snake_case_ ,				atol=snake_case_      )      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[str]:
       UpperCamelCase__         =    MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints      ).to(snake_case_      ).eval()
       UpperCamelCase__         =    self.default_image_processor
       UpperCamelCase__         =    prepare_img()
       UpperCamelCase__         =    image_processor(snake_case_ ,				return_tensors='pt'      ).to(snake_case_      )
       UpperCamelCase__         =    inputs['pixel_values'].shape
       # check size is divisible by 32
       self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0      )
       # check size
       self.assertEqual(snake_case_ ,				(1, 3, 384, 384)      )

       with torch.no_grad():
           UpperCamelCase__         =    model(**snake_case_      )
       # masks_queries_logits
       UpperCamelCase__         =    outputs.masks_queries_logits
       self.assertEqual(
           masks_queries_logits.shape ,				(1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)      )
       UpperCamelCase__         =    [
           [-8.7_839, -9.0_056, -8.8_121],
           [-7.4_104, -7.0_313, -6.5_401],
           [-6.6_105, -6.3_427, -6.4_675],
       ]
       UpperCamelCase__         =    torch.tensor(snake_case_      ).to(snake_case_      )
       self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] ,				snake_case_ ,				atol=snake_case_      )      )
       # class_queries_logits
       UpperCamelCase__         =    outputs.class_queries_logits
       self.assertEqual(class_queries_logits.shape ,				(1, model.config.num_queries, model.config.num_labels + 1)      )
       UpperCamelCase__         =    torch.tensor(
           [
               [1.8_324, -8.0_835, -4.1_922],
               [0.8_450, -9.0_050, -3.6_053],
               [0.3_045, -7.7_293, -3.0_275],
           ]      ).to(snake_case_      )
       self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] ,				snake_case_ ,				atol=snake_case_      )      )







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__         =    MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints      ).to(snake_case_      ).eval()
       UpperCamelCase__         =    self.default_image_processor

       UpperCamelCase__         =    image_processor(
           [np.zeros((3, 800, 1333)      ), np.zeros((3, 800, 1333)      )] ,				segmentation_maps=[np.zeros((384, 384)      ).astype(np.floataa      ), np.zeros((384, 384)      ).astype(np.floataa      )] ,				return_tensors='pt' ,				)

       UpperCamelCase__         =    inputs['pixel_values'].to(snake_case_      )
       UpperCamelCase__         =    [el.to(snake_case_      ) for el in inputs['mask_labels']]
       UpperCamelCase__         =    [el.to(snake_case_      ) for el in inputs['class_labels']]

       with torch.no_grad():
           UpperCamelCase__         =    model(**snake_case_      )

       self.assertTrue(outputs.loss is not None      )












"""simple docstring"""





from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import (
      TFConvBertForMaskedLM,
      TFConvBertForMultipleChoice,
      TFConvBertForQuestionAnswering,
      TFConvBertForSequenceClassification,
      TFConvBertForTokenClassification,
      TFConvBertModel,
  )
class    __lowerCamelCase    :

   def __init__(					self ,				snake_case_ ,				snake_case_=13 ,				snake_case_=7 ,				snake_case_=True ,				snake_case_=True ,				snake_case_=True ,				snake_case_=True ,				snake_case_=99 ,				snake_case_=32 ,				snake_case_=2 ,				snake_case_=4 ,				snake_case_=37 ,				snake_case_="gelu" ,				snake_case_=0.1 ,				snake_case_=0.1 ,				snake_case_=512 ,				snake_case_=16 ,				snake_case_=2 ,				snake_case_=0.02 ,				snake_case_=3 ,				snake_case_=4 ,				snake_case_=None ,				)		->       Tuple:
       UpperCamelCase__         =    parent
       UpperCamelCase__         =    13
       UpperCamelCase__         =    7
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True
       UpperCamelCase__         =    99
       UpperCamelCase__         =    384
       UpperCamelCase__         =    2
       UpperCamelCase__         =    4
       UpperCamelCase__         =    37
       UpperCamelCase__         =    'gelu'
       UpperCamelCase__         =    0.1
       UpperCamelCase__         =    0.1
       UpperCamelCase__         =    512
       UpperCamelCase__         =    16
       UpperCamelCase__         =    2
       UpperCamelCase__         =    0.02
       UpperCamelCase__         =    3
       UpperCamelCase__         =    4
       UpperCamelCase__         =    128
       UpperCamelCase__         =    2
       UpperCamelCase__         =    9
       UpperCamelCase__         =    1
       UpperCamelCase__         =    None

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    ids_tensor([self.batch_size, self.seq_length] ,				self.vocab_size      )

       UpperCamelCase__         =    None
       if self.use_input_mask:
           UpperCamelCase__         =    random_attention_mask([self.batch_size, self.seq_length]      )

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

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

       UpperCamelCase__         =    ConvBertConfig(
           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 ,				return_dict=snake_case_ ,				)

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

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       int:
       UpperCamelCase__         =    TFConvBertModel(config=snake_case_      )
       UpperCamelCase__         =    {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

       UpperCamelCase__         =    [input_ids, input_mask]
       UpperCamelCase__         =    model(snake_case_      )

       UpperCamelCase__         =    model(snake_case_      )

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

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       int:
       UpperCamelCase__         =    TFConvBertForMaskedLM(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.vocab_size)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[str]:
       UpperCamelCase__         =    self.num_labels
       UpperCamelCase__         =    TFConvBertForSequenceClassification(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }

       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_labels)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       Tuple:
       UpperCamelCase__         =    self.num_choices
       UpperCamelCase__         =    TFConvBertForMultipleChoice(config=snake_case_      )
       UpperCamelCase__         =    tf.tile(tf.expand_dims(snake_case_ ,				1      ) ,				(1, self.num_choices, 1)      )
       UpperCamelCase__         =    tf.tile(tf.expand_dims(snake_case_ ,				1      ) ,				(1, self.num_choices, 1)      )
       UpperCamelCase__         =    tf.tile(tf.expand_dims(snake_case_ ,				1      ) ,				(1, self.num_choices, 1)      )
       UpperCamelCase__         =    {
           'input_ids': multiple_choice_inputs_ids,
           'attention_mask': multiple_choice_input_mask,
           'token_type_ids': multiple_choice_token_type_ids,
       }
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_choices)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[str]:
       UpperCamelCase__         =    self.num_labels
       UpperCamelCase__         =    TFConvBertForTokenClassification(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.num_labels)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[Any]:
       UpperCamelCase__         =    TFConvBertForQuestionAnswering(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }

       UpperCamelCase__         =    model(snake_case_      )
       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 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__         =    self.prepare_config_and_inputs()
       (
           (
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						
       )         =    config_and_inputs
       UpperCamelCase__         =    {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
       return config, inputs_dict







@require_tf
class    __lowerCamelCase    (  _a							,	_a							,	unittest.TestCase  ):
   a      :				Any 						=(
       (
           TFConvBertModel,
           TFConvBertForMaskedLM,
           TFConvBertForQuestionAnswering,
           TFConvBertForSequenceClassification,
           TFConvBertForTokenClassification,
           TFConvBertForMultipleChoice,
       )
       if is_tf_available()
       else ()
   )
   a      :				str 						=(
       {
           """feature-extraction""": TFConvBertModel,
           """fill-mask""": TFConvBertForMaskedLM,
           """question-answering""": TFConvBertForQuestionAnswering,
           """text-classification""": TFConvBertForSequenceClassification,
           """token-classification""": TFConvBertForTokenClassification,
           """zero-shot""": TFConvBertForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   a      :				Any 						=False
   a      :				Dict 						=False
   a      :				str 						=False

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    TFConvBertModelTester(self      )
       UpperCamelCase__         =    ConfigTester(self ,				config_class=snake_case_ ,				hidden_size=37      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       self.config_tester.run_common_tests()

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[str]:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*snake_case_      )

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True

       if hasattr(snake_case_ ,				'use_cache'      ):
           UpperCamelCase__         =    True

       UpperCamelCase__         =    getattr(self.model_tester ,				'encoder_seq_length' ,				self.model_tester.seq_length      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'key_length' ,				snake_case_      )

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    self._prepare_for_class(snake_case_ ,				snake_case_      )
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    len(model(snake_case_      )      )

           with tempfile.TemporaryDirectory() as tmpdirname:
               model.save_pretrained(snake_case_ ,				saved_model=snake_case_      )
               UpperCamelCase__         =    os.path.join(snake_case_ ,				'saved_model' ,				'1'      )
               UpperCamelCase__         =    tf.keras.models.load_model(snake_case_      )
               UpperCamelCase__         =    model(snake_case_      )

               if self.is_encoder_decoder:
                   UpperCamelCase__         =    outputs['encoder_hidden_states']
                   UpperCamelCase__         =    outputs['encoder_attentions']
               else:
                   UpperCamelCase__         =    outputs['hidden_states']
                   UpperCamelCase__         =    outputs['attentions']

               self.assertEqual(len(snake_case_      ) ,				snake_case_      )

               UpperCamelCase__         =    getattr(
                   self.model_tester ,				'expected_num_hidden_layers' ,				self.model_tester.num_hidden_layers + 1      )

               self.assertEqual(len(snake_case_      ) ,				snake_case_      )
               self.assertListEqual(
                   list(output_hidden_states[0].shape[-2:]      ) ,				[self.model_tester.seq_length, self.model_tester.hidden_size] ,				)

               self.assertEqual(len(snake_case_      ) ,				self.model_tester.num_hidden_layers      )
               self.assertListEqual(
                   list(output_attentions[0].shape[-3:]      ) ,				[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length] ,				)

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    TFConvBertModel.from_pretrained('YituTech/conv-bert-base'      )
       self.assertIsNotNone(snake_case_      )







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase__         =    True
       UpperCamelCase__         =    getattr(self.model_tester ,				'decoder_seq_length' ,				self.model_tester.seq_length      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'encoder_seq_length' ,				self.model_tester.seq_length      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'key_length' ,				snake_case_      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'key_length' ,				snake_case_      )

       def check_decoder_attentions_output(snake_case_      ):
           UpperCamelCase__         =    len(snake_case_      )
           self.assertEqual(out_len % 2 ,				0      )
           UpperCamelCase__         =    outputs.decoder_attentions
           self.assertEqual(len(snake_case_      ) ,				self.model_tester.num_hidden_layers      )
           self.assertListEqual(
               list(decoder_attentions[0].shape[-3:]      ) ,				[self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length] ,				)

       def check_encoder_attentions_output(snake_case_      ):
           UpperCamelCase__         =    [
               t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
           ]
           self.assertEqual(len(snake_case_      ) ,				self.model_tester.num_hidden_layers      )
           self.assertListEqual(
               list(attentions[0].shape[-3:]      ) ,				[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length] ,				)

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    True
           UpperCamelCase__         =    False
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )
           UpperCamelCase__         =    len(snake_case_      )
           self.assertEqual(config.output_hidden_states ,				snake_case_      )
           check_encoder_attentions_output(snake_case_      )

           if self.is_encoder_decoder:
               UpperCamelCase__         =    model_class(snake_case_      )
               UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )
               self.assertEqual(config.output_hidden_states ,				snake_case_      )
               check_decoder_attentions_output(snake_case_      )

           # Check that output attentions can also be changed via the config
           del inputs_dict["output_attentions"]
           UpperCamelCase__         =    True
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )
           self.assertEqual(config.output_hidden_states ,				snake_case_      )
           check_encoder_attentions_output(snake_case_      )

           # Check attention is always last and order is fine
           UpperCamelCase__         =    True
           UpperCamelCase__         =    True
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )

           self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1) ,				len(snake_case_      )      )
           self.assertEqual(model.config.output_hidden_states ,				snake_case_      )
           check_encoder_attentions_output(snake_case_      )







@require_tf
class    __lowerCamelCase    (  unittest.TestCase  ):

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__         =    TFConvBertModel.from_pretrained('YituTech/conv-bert-base'      )
       UpperCamelCase__         =    tf.constant([[0, 1, 2, 3, 4, 5]]      )
       UpperCamelCase__         =    model(snake_case_      )[0]

       UpperCamelCase__         =    [1, 6, 768]
       self.assertEqual(output.shape ,				snake_case_      )

       UpperCamelCase__         =    tf.constant(
           [
               [
                   [-0.03_475_493, -0.4_686_034, -0.30_638_832],
                   [0.22_637_248, -0.26_988_646, -0.7_423_424],
                   [0.10_324_868, -0.45_013_508, -0.58_280_784],
               ]
           ]      )
       tf.debugging.assert_near(output[:, :3, :3] ,				snake_case_ ,				atol=1E-4      )




