



'''simple docstring'''





import random

import torch
from huggingface_hub import HfApi

from diffusers import UNetaDModel


_UpperCamelCase											=		HfApi()

_UpperCamelCase											=		{}
# fmt: off
_UpperCamelCase											=		torch.tensor([
    -0.7_5_1_5, -1.6_8_8_3, 0.2_4_2_0, 0.0_3_0_0, 0.6_3_4_7, 1.3_4_3_3, -1.1_7_4_3, -3.7_4_6_7,
    1.2_3_4_2, -2.2_4_8_5, 0.4_6_3_6, 0.8_0_7_6, -0.7_9_9_1, 0.3_9_6_9, 0.8_4_9_8, 0.9_1_8_9,
    -1.8_8_8_7, -3.3_5_2_2, 0.7_6_3_9, 0.2_0_4_0, 0.6_2_7_1, -2.7_1_4_8, -1.6_3_1_6, 3.0_8_3_9,
    0.3_1_8_6, 0.2_7_2_1, -0.9_7_5_9, -1.2_4_6_1, 2.6_2_5_7, 1.3_5_5_7
])
_UpperCamelCase											=		torch.tensor([
    -2.3_6_3_9, -2.5_3_4_4, 0.0_0_5_4, -0.6_6_7_4, 1.5_9_9_0, 1.0_1_5_8, 0.3_1_2_4, -2.1_4_3_6,
    1.8_7_9_5, -2.5_4_2_9, -0.1_5_6_6, -0.3_9_7_3, 1.2_4_9_0, 2.6_4_4_7, 1.2_2_8_3, -0.5_2_0_8,
    -2.8_1_5_4, -3.5_1_1_9, 2.3_8_3_8, 1.2_0_3_3, 1.7_2_0_1, -2.1_2_5_6, -1.4_5_7_6, 2.7_9_4_8,
    2.4_2_0_4, -0.9_7_5_2, -1.2_5_4_6, 0.8_0_2_7, 3.2_7_5_8, 3.1_3_6_5
])
_UpperCamelCase											=		torch.tensor([
    -0.6_5_3_1, -0.6_8_9_1, -0.3_1_7_2, -0.5_3_7_5, -0.9_1_4_0, -0.5_3_6_7, -0.1_1_7_5, -0.7_8_6_9,
    -0.3_8_0_8, -0.4_5_1_3, -0.2_0_9_8, -0.0_0_8_3, 0.3_1_8_3, 0.5_1_4_0, 0.2_2_4_7, -0.1_3_0_4,
    -0.1_3_0_2, -0.2_8_0_2, -0.2_0_8_4, -0.2_0_2_5, -0.4_9_6_7, -0.4_8_7_3, -0.0_8_6_1, 0.6_9_2_5,
    0.0_2_5_0, 0.1_2_9_0, -0.1_5_4_3, 0.6_3_1_6, 1.0_4_6_0, 1.4_9_4_3
])
_UpperCamelCase											=		torch.tensor([
    0.0_9_1_1, 0.1_1_0_7, 0.0_1_8_2, 0.0_4_3_5, -0.0_8_0_5, -0.0_6_0_8, 0.0_3_8_1, 0.2_1_7_2,
    -0.0_2_8_0, 0.1_3_2_7, -0.0_2_9_9, -0.0_2_5_5, -0.0_0_5_0, -0.1_1_7_0, -0.1_0_4_6, 0.0_3_0_9,
    0.1_3_6_7, 0.1_7_2_8, -0.0_5_3_3, -0.0_7_4_8, -0.0_5_3_4, 0.1_6_2_4, 0.0_3_8_4, -0.1_8_0_5,
    -0.0_7_0_7, 0.0_6_4_2, 0.0_2_2_0, -0.0_1_3_4, -0.1_3_3_3, -0.1_5_0_5
])
_UpperCamelCase											=		torch.tensor([
    0.1_3_2_1, 0.1_3_3_7, 0.0_4_4_0, 0.0_6_2_2, -0.0_5_9_1, -0.0_3_7_0, 0.0_5_0_3, 0.2_1_3_3,
    -0.0_1_7_7, 0.1_4_1_5, -0.0_1_1_6, -0.0_1_1_2, 0.0_0_4_4, -0.0_9_8_0, -0.0_7_8_9, 0.0_3_9_5,
    0.1_5_0_2, 0.1_7_8_5, -0.0_4_8_8, -0.0_5_1_4, -0.0_4_0_4, 0.1_5_3_9, 0.0_4_5_4, -0.1_5_5_9,
    -0.0_6_6_5, 0.0_6_5_9, 0.0_3_8_3, -0.0_0_0_5, -0.1_2_6_6, -0.1_3_8_6
])
_UpperCamelCase											=		torch.tensor([
    0.1_1_5_4, 0.1_2_1_8, 0.0_3_0_7, 0.0_5_2_6, -0.0_7_1_1, -0.0_5_4_1, 0.0_3_6_6, 0.2_0_7_8,
    -0.0_2_6_7, 0.1_3_1_7, -0.0_2_2_6, -0.0_1_9_3, -0.0_0_1_4, -0.1_0_5_5, -0.0_9_0_2, 0.0_3_3_0,
    0.1_3_9_1, 0.1_7_0_9, -0.0_5_6_2, -0.0_6_9_3, -0.0_5_6_0, 0.1_4_8_2, 0.0_3_8_1, -0.1_6_8_3,
    -0.0_6_8_1, 0.0_6_6_1, 0.0_3_3_1, -0.0_0_4_6, -0.1_2_6_8, -0.1_4_3_1
])
_UpperCamelCase											=		torch.tensor([
    0.1_1_9_2, 0.1_2_4_0, 0.0_4_1_4, 0.0_6_0_6, -0.0_5_5_7, -0.0_4_1_2, 0.0_4_3_0, 0.2_0_4_2,
    -0.0_2_0_0, 0.1_3_8_5, -0.0_1_1_5, -0.0_1_3_2, 0.0_0_1_7, -0.0_9_6_5, -0.0_8_0_2, 0.0_3_9_8,
    0.1_4_3_3, 0.1_7_4_7, -0.0_4_5_8, -0.0_5_3_3, -0.0_4_0_7, 0.1_5_4_5, 0.0_4_1_9, -0.1_5_7_4,
    -0.0_6_4_5, 0.0_6_2_6, 0.0_3_4_1, -0.0_0_1_0, -0.1_1_9_9, -0.1_3_9_0
])
_UpperCamelCase											=		torch.tensor([
    0.1_0_7_5, 0.1_0_7_4, 0.0_2_0_5, 0.0_4_3_1, -0.0_7_7_4, -0.0_6_0_7, 0.0_2_9_8, 0.2_0_4_2,
    -0.0_3_2_0, 0.1_2_6_7, -0.0_2_8_1, -0.0_2_5_0, -0.0_0_6_4, -0.1_0_9_1, -0.0_9_4_6, 0.0_2_9_0,
    0.1_3_2_8, 0.1_6_5_0, -0.0_5_8_0, -0.0_7_3_8, -0.0_5_8_6, 0.1_4_4_0, 0.0_3_3_7, -0.1_7_4_6,
    -0.0_7_1_2, 0.0_6_0_5, 0.0_2_5_0, -0.0_0_9_9, -0.1_3_1_6, -0.1_4_7_3
])
_UpperCamelCase											=		torch.tensor([
    -1.4_5_7_2, -2.0_4_8_1, -0.0_4_1_4, -0.6_0_0_5, 1.4_1_3_6, 0.5_8_4_8, 0.4_0_2_8, -2.7_3_3_0,
    1.2_2_1_2, -2.1_2_2_8, 0.2_1_5_5, 0.4_0_3_9, 0.7_6_6_2, 2.0_5_3_5, 0.7_4_7_7, -0.3_2_4_3,
    -2.1_7_5_8, -2.7_6_4_8, 1.6_9_4_7, 0.7_0_2_6, 1.2_3_3_8, -1.6_0_7_8, -0.8_6_8_2, 2.2_8_1_0,
    1.8_5_7_4, -0.5_7_1_8, -0.5_5_8_6, -0.0_1_8_6, 2.3_4_1_5, 2.1_2_5_1])
_UpperCamelCase											=		torch.tensor([
    -1.3_6_9_0, -1.9_7_2_0, -0.4_0_9_0, -0.6_9_6_6, 1.4_6_6_0, 0.9_9_3_8, -0.1_3_8_5, -2.7_3_2_4,
    0.7_7_3_6, -1.8_9_1_7, 0.2_9_2_3, 0.4_2_9_3, 0.1_6_9_3, 1.4_1_1_2, 1.1_8_8_7, -0.3_1_8_1,
    -2.2_1_6_0, -2.6_3_8_1, 1.3_1_7_0, 0.8_1_6_3, 0.9_2_4_0, -1.6_5_4_4, -0.6_0_9_9, 2.5_2_5_9,
    1.6_4_3_0, -0.9_0_9_0, -0.9_3_9_2, -0.0_1_2_6, 2.4_2_6_8, 2.3_2_6_6
])
_UpperCamelCase											=		torch.tensor([
    -1.3_5_2_5, -1.9_6_2_8, -0.3_9_5_6, -0.6_8_6_0, 1.4_6_6_4, 1.0_0_1_4, -0.1_2_5_9, -2.7_2_1_2,
    0.7_7_7_2, -1.8_8_1_1, 0.2_9_9_6, 0.4_3_8_8, 0.1_7_0_4, 1.4_0_2_9, 1.1_7_0_1, -0.3_0_2_7,
    -2.2_0_5_3, -2.6_2_8_7, 1.3_3_5_0, 0.8_1_3_1, 0.9_2_7_4, -1.6_2_9_2, -0.6_0_9_8, 2.5_1_3_1,
    1.6_5_0_5, -0.8_9_5_8, -0.9_2_9_8, -0.0_1_5_1, 2.4_2_5_7, 2.3_3_5_5
])
_UpperCamelCase											=		torch.tensor([
    -2.0_5_8_5, -2.7_8_9_7, -0.2_8_5_0, -0.8_9_4_0, 1.9_0_5_2, 0.5_7_0_2, 0.6_3_4_5, -3.8_9_5_9,
    1.5_9_3_2, -3.2_3_1_9, 0.1_9_7_4, 0.0_2_8_7, 1.7_5_6_6, 2.6_5_4_3, 0.8_3_8_7, -0.5_3_5_1,
    -3.2_7_3_6, -4.3_3_7_5, 2.9_0_2_9, 1.6_3_9_0, 1.4_6_4_0, -2.1_7_0_1, -1.9_0_1_3, 2.9_3_4_1,
    3.4_9_8_1, -0.6_2_5_5, -1.1_6_4_4, -0.1_5_9_1, 3.7_0_9_7, 3.2_0_6_6
])
_UpperCamelCase											=		torch.tensor([
    -2.3_1_3_9, -2.5_5_9_4, -0.0_1_9_7, -0.6_7_8_5, 1.7_0_0_1, 1.1_6_0_6, 0.3_0_7_5, -2.1_7_4_0,
    1.8_0_7_1, -2.5_6_3_0, -0.0_9_2_6, -0.3_8_1_1, 1.2_1_1_6, 2.6_2_4_6, 1.2_7_3_1, -0.5_3_9_8,
    -2.8_1_5_3, -3.6_1_4_0, 2.3_8_9_3, 1.3_2_6_2, 1.6_2_5_8, -2.1_8_5_6, -1.3_2_6_7, 2.8_3_9_5,
    2.3_7_7_9, -1.0_6_2_3, -1.2_4_6_8, 0.8_9_5_9, 3.3_3_6_7, 3.2_2_4_3
])
_UpperCamelCase											=		torch.tensor([
    -2.0_6_2_8, -2.7_6_6_7, -0.2_0_8_9, -0.8_2_6_3, 2.0_5_3_9, 0.5_9_9_2, 0.6_4_9_5, -3.8_3_3_6,
    1.6_0_2_5, -3.2_8_1_7, 0.1_7_2_1, -0.0_6_3_3, 1.7_5_1_6, 2.7_0_3_9, 0.8_1_0_0, -0.5_9_0_8,
    -3.2_1_1_3, -4.4_3_4_3, 2.9_2_5_7, 1.3_6_3_2, 1.5_5_6_2, -2.1_4_8_9, -1.9_8_9_4, 3.0_5_6_0,
    3.3_3_9_6, -0.7_3_2_8, -1.0_4_1_7, 0.0_3_8_3, 3.7_0_9_3, 3.2_3_4_3
])
_UpperCamelCase											=		torch.tensor([
    -1.4_5_7_4, -2.0_5_6_9, -0.0_4_7_3, -0.6_1_1_7, 1.4_0_1_8, 0.5_7_6_9, 0.4_1_2_9, -2.7_3_4_4,
    1.2_2_4_1, -2.1_3_9_7, 0.2_0_0_0, 0.3_9_3_7, 0.7_6_1_6, 2.0_4_5_3, 0.7_3_2_4, -0.3_3_9_1,
    -2.1_7_4_6, -2.7_7_4_4, 1.6_9_6_3, 0.6_9_2_1, 1.2_1_8_7, -1.6_1_7_2, -0.8_8_7_7, 2.2_4_3_9,
    1.8_4_7_1, -0.5_8_3_9, -0.5_6_0_5, -0.0_4_6_4, 2.3_2_5_0, 2.1_2_1_9
])
# fmt: on

_UpperCamelCase											=		api.list_models(filter='diffusers')
for mod in models:
   if "google" in mod.author or mod.modelId == "CompVis/ldm-celebahq-256":
      _UpperCamelCase											=		'/home/patrick/google_checkpoints/' + mod.modelId.split('/')[-1]

      print(f'''Started running {mod.modelId}!!!''')

      if mod.modelId.startswith('CompVis'):
         _UpperCamelCase											=		UNetaDModel.from_pretrained(local_checkpoint, subfolder='unet')
      else:
         _UpperCamelCase											=		UNetaDModel.from_pretrained(local_checkpoint)

      torch.manual_seed(0)
      random.seed(0)

      _UpperCamelCase											=		torch.randn(1, model.config.in_channels, model.config.sample_size, model.config.sample_size)
      _UpperCamelCase											=		torch.tensor([10] * noise.shape[0])
      with torch.no_grad():
         _UpperCamelCase											=		model(noise, time_step).sample

      assert torch.allclose(
          logits[0, 0, 0, :30], results['_'.join('_'.join(mod.modelId.split('/')).split('-'))], atol=1e-3
      )
      print(f'''{mod.modelId} has passed successfully!!!''')











'''simple docstring'''





import unittest

from transformers import DebertaVaConfig, 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       DebertaVaForMaskedLM,
       DebertaVaForMultipleChoice,
       DebertaVaForQuestionAnswering,
       DebertaVaForSequenceClassification,
       DebertaVaForTokenClassification,
       DebertaVaModel,
   )
   from transformers.models.deberta_va.modeling_deberta_va import DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST






class    lowerCamelCase_       (							SCREAMING_SNAKE_CASE_	):
  """simple docstring"""




  def __init__(					self :      Dict     ,      _a :      int     ,      _a :      Any=13     ,      _a :      Union[str, Any]=7     ,      _a :      int=True     ,      _a :      Optional[int]=True     ,      _a :      Union[str, Any]=True     ,      _a :      Dict=True     ,      _a :      Optional[Any]=99     ,      _a :      List[str]=32     ,      _a :      Union[str, Any]=5     ,      _a :      Optional[Any]=4     ,      _a :      Dict=37     ,      _a :      Dict="gelu"     ,      _a :      Optional[int]=0.1     ,      _a :      Tuple=0.1     ,      _a :      Dict=512     ,      _a :      Tuple=16     ,      _a :      List[str]=2     ,      _a :      Union[str, Any]=0.02     ,      _a :      List[Any]=False     ,      _a :      str=True     ,      _a :      List[Any]="None"     ,      _a :      Dict=3     ,      _a :      Union[str, Any]=4     ,      _a :      Union[str, Any]=None     ,      )   ->   List[str]:
    __lowerCamelCase			:			Any       			=					parent
    __lowerCamelCase			:			List[Any]       			=					batch_size
    __lowerCamelCase			:			str       			=					seq_length
    __lowerCamelCase			:			Dict       			=					is_training
    __lowerCamelCase			:			str       			=					use_input_mask
    __lowerCamelCase			:			Any       			=					use_token_type_ids
    __lowerCamelCase			:			Dict       			=					use_labels
    __lowerCamelCase			:			str       			=					vocab_size
    __lowerCamelCase			:			Optional[Any]       			=					hidden_size
    __lowerCamelCase			:			Union[str, Any]       			=					num_hidden_layers
    __lowerCamelCase			:			Union[str, Any]       			=					num_attention_heads
    __lowerCamelCase			:			str       			=					intermediate_size
    __lowerCamelCase			:			Union[str, Any]       			=					hidden_act
    __lowerCamelCase			:			Tuple       			=					hidden_dropout_prob
    __lowerCamelCase			:			Union[str, Any]       			=					attention_probs_dropout_prob
    __lowerCamelCase			:			Optional[Any]       			=					max_position_embeddings
    __lowerCamelCase			:			Tuple       			=					type_vocab_size
    __lowerCamelCase			:			Dict       			=					type_sequence_label_size
    __lowerCamelCase			:			str       			=					initializer_range
    __lowerCamelCase			:			Tuple       			=					num_labels
    __lowerCamelCase			:			Optional[Any]       			=					num_choices
    __lowerCamelCase			:			Any       			=					relative_attention
    __lowerCamelCase			:			Any       			=					position_biased_input
    __lowerCamelCase			:			Dict       			=					pos_att_type
    __lowerCamelCase			:			Any       			=					scope




  def 		_lowercase	(					self :      Dict  )   ->   str:
    __lowerCamelCase			:			List[str]       			=					ids_tensor([self.batch_size, self.seq_length]     ,      self.vocab_size  )

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

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

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

    __lowerCamelCase			:			List[str]       			=					self.get_config()

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




  def 		_lowercase	(					self :      List[str]  )   ->   Optional[int]:
    return DebertaVaConfig(
        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     ,      relative_attention=self.relative_attention     ,      position_biased_input=self.position_biased_input     ,      pos_att_type=self.pos_att_type     ,      )




  def 		_lowercase	(					self :      Any     ,      _a :      Optional[Any]  )   ->   Any:
    self.parent.assertListEqual(list(result.loss.size()  )     ,      []  )




  def 		_lowercase	(					self :      List[str]     ,      _a :      Any     ,      _a :      List[str]     ,      _a :      List[Any]     ,      _a :      Dict     ,      _a :      Union[str, Any]     ,      _a :      Tuple     ,      _a :      List[Any]  )   ->   List[str]:
    __lowerCamelCase			:			str       			=					DebertaVaModel(config=_a  )
    model.to(_a  )
    model.eval()
    __lowerCamelCase			:			Optional[Any]       			=					model(_a     ,      attention_mask=_a     ,      token_type_ids=_a  )[0]
    __lowerCamelCase			:			List[Any]       			=					model(_a     ,      token_type_ids=_a  )[0]
    __lowerCamelCase			:			int       			=					model(_a  )[0]

    self.parent.assertListEqual(list(sequence_output.size()  )     ,      [self.batch_size, self.seq_length, self.hidden_size]  )




  def 		_lowercase	(					self :      Union[str, Any]     ,      _a :      str     ,      _a :      Optional[int]     ,      _a :      Dict     ,      _a :      Optional[int]     ,      _a :      Dict     ,      _a :      Optional[Any]     ,      _a :      Optional[Any]  )   ->   str:
    __lowerCamelCase			:			List[Any]       			=					DebertaVaForMaskedLM(config=_a  )
    model.to(_a  )
    model.eval()
    __lowerCamelCase			:			Optional[int]       			=					model(_a     ,      attention_mask=_a     ,      token_type_ids=_a     ,      labels=_a  )

    self.parent.assertEqual(result.logits.shape     ,      (self.batch_size, self.seq_length, self.vocab_size)  )




  def 		_lowercase	(					self :      Optional[Any]     ,      _a :      List[str]     ,      _a :      str     ,      _a :      Any     ,      _a :      Dict     ,      _a :      Optional[Any]     ,      _a :      Optional[Any]     ,      _a :      str  )   ->   List[Any]:
    __lowerCamelCase			:			List[str]       			=					self.num_labels
    __lowerCamelCase			:			List[str]       			=					DebertaVaForSequenceClassification(_a  )
    model.to(_a  )
    model.eval()
    __lowerCamelCase			:			Tuple       			=					model(_a     ,      attention_mask=_a     ,      token_type_ids=_a     ,      labels=_a  )
    self.parent.assertListEqual(list(result.logits.size()  )     ,      [self.batch_size, self.num_labels]  )
    self.check_loss_output(_a  )




  def 		_lowercase	(					self :      int     ,      _a :      List[str]     ,      _a :      Union[str, Any]     ,      _a :      Any     ,      _a :      int     ,      _a :      Optional[int]     ,      _a :      Tuple     ,      _a :      Tuple  )   ->   Union[str, Any]:
    __lowerCamelCase			:			Union[str, Any]       			=					self.num_labels
    __lowerCamelCase			:			Union[str, Any]       			=					DebertaVaForTokenClassification(config=_a  )
    model.to(_a  )
    model.eval()
    __lowerCamelCase			:			str       			=					model(_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 		_lowercase	(					self :      Union[str, Any]     ,      _a :      Optional[int]     ,      _a :      List[Any]     ,      _a :      Optional[Any]     ,      _a :      List[str]     ,      _a :      Optional[int]     ,      _a :      Union[str, Any]     ,      _a :      Any  )   ->   Tuple:
    __lowerCamelCase			:			int       			=					DebertaVaForQuestionAnswering(config=_a  )
    model.to(_a  )
    model.eval()
    __lowerCamelCase			:			List[str]       			=					model(
        _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 		_lowercase	(					self :      Union[str, Any]     ,      _a :      Any     ,      _a :      List[str]     ,      _a :      str     ,      _a :      str     ,      _a :      List[Any]     ,      _a :      Tuple     ,      _a :      str  )   ->   Optional[int]:
    __lowerCamelCase			:			Union[str, Any]       			=					DebertaVaForMultipleChoice(config=_a  )
    model.to(_a  )
    model.eval()
    __lowerCamelCase			:			List[Any]       			=					input_ids.unsqueeze(1  ).expand(-1     ,      self.num_choices     ,      -1  ).contiguous()
    __lowerCamelCase			:			List[str]       			=					token_type_ids.unsqueeze(1  ).expand(-1     ,      self.num_choices     ,      -1  ).contiguous()
    __lowerCamelCase			:			Union[str, Any]       			=					input_mask.unsqueeze(1  ).expand(-1     ,      self.num_choices     ,      -1  ).contiguous()
    __lowerCamelCase			:			Optional[int]       			=					model(
        _a     ,      attention_mask=_a     ,      token_type_ids=_a     ,      labels=_a     ,      )
    self.parent.assertEqual(result.logits.shape     ,      (self.batch_size, self.num_choices)  )




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






@require_torch
class    lowerCamelCase_       (							SCREAMING_SNAKE_CASE_  ,  SCREAMING_SNAKE_CASE_  ,  unittest.TestCase	):
  """simple docstring"""




  a_				   =(
      (
          DebertaVaModel,
          DebertaVaForMaskedLM,
          DebertaVaForSequenceClassification,
          DebertaVaForTokenClassification,
          DebertaVaForQuestionAnswering,
          DebertaVaForMultipleChoice,
      )
      if is_torch_available()
      else ()
  )
  a_				   =(
      {
          """feature-extraction""": DebertaVaModel,
          """fill-mask""": DebertaVaForMaskedLM,
          """question-answering""": DebertaVaForQuestionAnswering,
          """text-classification""": DebertaVaForSequenceClassification,
          """token-classification""": DebertaVaForTokenClassification,
          """zero-shot""": DebertaVaForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )

  a_				   =True
  a_				   =False
  a_				   =False
  a_				   =False
  a_				   =False




  def 		_lowercase	(					self :      Tuple  )   ->   Dict:
    __lowerCamelCase			:			str       			=					DebertaVaModelTester(self  )
    __lowerCamelCase			:			Dict       			=					ConfigTester(self     ,      config_class=_a     ,      hidden_size=37  )




  def 		_lowercase	(					self :      int  )   ->   List[str]:
    self.config_tester.run_common_tests()




  def 		_lowercase	(					self :      Any  )   ->   int:
    __lowerCamelCase			:			Any       			=					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_deberta_model(*_a  )




  def 		_lowercase	(					self :      Dict  )   ->   Tuple:
    __lowerCamelCase			:			List[str]       			=					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_deberta_for_sequence_classification(*_a  )




  def 		_lowercase	(					self :      Tuple  )   ->   Optional[Any]:
    __lowerCamelCase			:			Tuple       			=					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_deberta_for_masked_lm(*_a  )




  def 		_lowercase	(					self :      Union[str, Any]  )   ->   Optional[Any]:
    __lowerCamelCase			:			Union[str, Any]       			=					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_deberta_for_question_answering(*_a  )




  def 		_lowercase	(					self :      Union[str, Any]  )   ->   List[Any]:
    __lowerCamelCase			:			int       			=					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_deberta_for_token_classification(*_a  )




  def 		_lowercase	(					self :      Optional[Any]  )   ->   List[Any]:
    __lowerCamelCase			:			Tuple       			=					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_deberta_for_multiple_choice(*_a  )




  @slow
  def 		_lowercase	(					self :      Optional[int]  )   ->   int:
    for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      __lowerCamelCase			:			Any       			=					DebertaVaModel.from_pretrained(_a  )
      self.assertIsNotNone(_a  )






@require_torch
@require_sentencepiece
@require_tokenizers
class    lowerCamelCase_       (							unittest.TestCase	):
  """simple docstring"""




  @unittest.skip(reason='Model not available yet'  )
  def 		_lowercase	(					self :      List[str]  )   ->   Dict:
    pass




  @slow
  def 		_lowercase	(					self :      List[str]  )   ->   List[Any]:
    __lowerCamelCase			:			List[Any]       			=					DebertaVaModel.from_pretrained('microsoft/deberta-v2-xlarge'  )

    __lowerCamelCase			:			Optional[Any]       			=					torch.tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]]  )
    __lowerCamelCase			:			List[str]       			=					torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
    with torch.no_grad():
      __lowerCamelCase			:			List[str]       			=					model(_a     ,      attention_mask=_a  )[0]
    # compare the actual values for a slice.
    __lowerCamelCase			:			Tuple       			=					torch.tensor(
        [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]]  )
    self.assertTrue(torch.allclose(output[:, 1:4, 1:4]     ,      _a     ,      atol=1e-4  )     ,      f'{output[:, 1:4, 1:4]}'  )






