

import inspect
import os

import torch
from transformers import AutoModel
from transformers.testing_utils import mockenv_context
from transformers.trainer_utils import set_seed

import accelerate
from accelerate.accelerator import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils.testing import (
    AccelerateTestCase,
    TempDirTestCase,
    execute_subprocess_async,
    require_cuda,
    require_fsdp,
    require_multi_gpu,
    slow,
)
from accelerate.utils.constants import (
    FSDP_AUTO_WRAP_POLICY,
    FSDP_BACKWARD_PREFETCH,
    FSDP_SHARDING_STRATEGY,
    FSDP_STATE_DICT_TYPE,
)
from accelerate.utils.dataclasses import FullyShardedDataParallelPlugin
from accelerate.utils.other import patch_environment


set_seed(42)

__lowercase				      =						"""bert-base-cased"""
__lowercase				      =						"""fp16"""
__lowercase				      =						"""bf16"""
__lowercase				      =						[FPaa, BFaa]

@require_fsdp
@require_cuda
class    _lowercase				(					__lowerCamelCase			):

   def     UpperCamelCase					(				self	:    Union[str, Any]       ) ->			List[Any]:
         """simple docstring"""





         super().setUp()

         A_							       =		dict(
             ACCELERATE_USE_FSDP='''true'''			,						MASTER_ADDR='''localhost'''			,						MASTER_PORT='''10999'''			,						RANK='''0'''			,						LOCAL_RANK='''0'''			,						WORLD_SIZE='''1'''			,						)

   def     UpperCamelCase					(				self	:    str       ) ->			Optional[int]:
         """simple docstring"""





         from torch.distributed.fsdp.fully_sharded_data_parallel import ShardingStrategy

         for i, strategy in enumerate(lowerCamelCase__       ):
               A_							       =		self.dist_env.copy()
               A_							       =		F"{i + 1}"
               A_							       =		strategy
               with mockenv_context(**lowerCamelCase__       ):
                     A_							       =		FullyShardedDataParallelPlugin()
                     self.assertEqual(fsdp_plugin.sharding_strategy			,						ShardingStrategy(i + 1       )       )

   def     UpperCamelCase					(				self	:    Union[str, Any]       ) ->			Tuple:
         """simple docstring"""





         from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch

         for i, prefetch_policy in enumerate(lowerCamelCase__       ):
               A_							       =		self.dist_env.copy()
               A_							       =		prefetch_policy
               with mockenv_context(**lowerCamelCase__       ):
                     A_							       =		FullyShardedDataParallelPlugin()
                     if prefetch_policy == "NO_PREFETCH":
                           self.assertIsNone(fsdp_plugin.backward_prefetch       )
                     else:
                           self.assertEqual(fsdp_plugin.backward_prefetch			,						BackwardPrefetch(i + 1       )       )

   def     UpperCamelCase					(				self	:    Optional[Any]       ) ->			List[Any]:
         """simple docstring"""





         from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType

         for i, state_dict_type in enumerate(lowerCamelCase__       ):
               A_							       =		self.dist_env.copy()
               A_							       =		state_dict_type
               with mockenv_context(**lowerCamelCase__       ):
                     A_							       =		FullyShardedDataParallelPlugin()
                     self.assertEqual(fsdp_plugin.state_dict_type			,						StateDictType(i + 1       )       )
                     if state_dict_type == "FULL_STATE_DICT":
                           self.assertTrue(fsdp_plugin.state_dict_config.offload_to_cpu       )
                           self.assertTrue(fsdp_plugin.state_dict_config.ranka_only       )

   def     UpperCamelCase					(				self	:    Tuple       ) ->			List[Any]:
         """simple docstring"""





         A_							       =		AutoModel.from_pretrained(lowerCamelCase__       )
         for policy in FSDP_AUTO_WRAP_POLICY:
               A_							       =		self.dist_env.copy()
               A_							       =		policy
               if policy == "TRANSFORMER_BASED_WRAP":
                     A_							       =		'''BertLayer'''
               elif policy == "SIZE_BASED_WRAP":
                     A_							       =		'''2000'''
               with mockenv_context(**lowerCamelCase__       ):
                     A_							       =		FullyShardedDataParallelPlugin()
                     fsdp_plugin.set_auto_wrap_policy(lowerCamelCase__       )
                     if policy == "NO_WRAP":
                           self.assertIsNone(fsdp_plugin.auto_wrap_policy       )
                     else:
                           self.assertIsNotNone(fsdp_plugin.auto_wrap_policy       )

         A_							       =		self.dist_env.copy()
         A_							       =		'''TRANSFORMER_BASED_WRAP'''
         A_							       =		'''T5Layer'''
         with mockenv_context(**lowerCamelCase__       ):
               A_							       =		FullyShardedDataParallelPlugin()
               with self.assertRaises(lowerCamelCase__       ) as cm:
                     fsdp_plugin.set_auto_wrap_policy(lowerCamelCase__       )
               self.assertTrue('''Could not find the transformer layer class to wrap in the model.''' in str(cm.exception       )       )

         A_							       =		self.dist_env.copy()
         A_							       =		'''SIZE_BASED_WRAP'''
         A_							       =		'''0'''
         with mockenv_context(**lowerCamelCase__       ):
               A_							       =		FullyShardedDataParallelPlugin()
               fsdp_plugin.set_auto_wrap_policy(lowerCamelCase__       )
               self.assertIsNone(fsdp_plugin.auto_wrap_policy       )

   def     UpperCamelCase					(				self	:    Tuple       ) ->			List[Any]:
         """simple docstring"""





         from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision
         from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler

         for mp_dtype in dtypes:
               A_							       =		self.dist_env.copy()
               A_							       =		mp_dtype
               with mockenv_context(**lowerCamelCase__       ):
                     A_							       =		Accelerator()
                     if mp_dtype == "fp16":
                           A_							       =		torch.floataa
                     elif mp_dtype == "bf16":
                           A_							       =		torch.bfloataa
                     A_							       =		MixedPrecision(param_dtype=lowerCamelCase__			,						reduce_dtype=lowerCamelCase__			,						buffer_dtype=lowerCamelCase__       )
                     self.assertEqual(accelerator.state.fsdp_plugin.mixed_precision_policy			,						lowerCamelCase__       )
                     if mp_dtype == FPaa:
                           self.assertTrue(isinstance(accelerator.scaler			,						lowerCamelCase__       )       )
                     elif mp_dtype == BFaa:
                           self.assertIsNone(accelerator.scaler       )
                     AcceleratorState._reset_state(lowerCamelCase__       )





   def     UpperCamelCase					(				self	:    List[Any]       ) ->			int:
         """simple docstring"""





         from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload

         for flag in [True, False]:
               A_							       =		self.dist_env.copy()
               A_							       =		str(lowerCamelCase__       ).lower()
               with mockenv_context(**lowerCamelCase__       ):
                     A_							       =		FullyShardedDataParallelPlugin()
                     self.assertEqual(fsdp_plugin.cpu_offload			,						CPUOffload(offload_params=lowerCamelCase__       )       )



@require_fsdp
@require_multi_gpu
@slow
class    _lowercase				(					__lowerCamelCase			):

   def     UpperCamelCase					(				self	:    Tuple       ) ->			Optional[int]:
         """simple docstring"""





         super().setUp()
         A_							       =		0.82
         A_							       =		[
             '''fsdp_shard_grad_op_transformer_based_wrap''',
             '''fsdp_full_shard_transformer_based_wrap''',
         ]
         A_							       =		{
             '''multi_gpu_fp16''': 3_2_0_0,
             '''fsdp_shard_grad_op_transformer_based_wrap_fp16''': 2_0_0_0,
             '''fsdp_full_shard_transformer_based_wrap_fp16''': 1_9_0_0,
             # Disabling below test as it overwhelms the RAM memory usage
             # on CI self-hosted runner leading to tests getting killed.
             # "fsdp_full_shard_cpu_offload_transformer_based_wrap_fp32": 1500,  # fp16 was leading to indefinite hang
         }
         A_							       =		1_6_0
         A_							       =		1_6_0

         A_							       =		inspect.getfile(accelerate.test_utils       )
         A_							       =		os.path.sep.join(mod_file.split(os.path.sep       )[:-1] + ['''scripts''', '''external_deps''']       )

   def     UpperCamelCase					(				self	:    Optional[Any]       ) ->			str:
         """simple docstring"""





         A_							       =		os.path.join(self.test_scripts_folder			,						'''test_performance.py'''       )
         A_							       =		['''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', '''--use_fsdp''']
         for config in self.performance_configs:
               A_							       =		cmd.copy()
               for i, strategy in enumerate(lowerCamelCase__       ):
                     if strategy.lower() in config:
                           cmd_config.append(F"--fsdp_sharding_strategy={i+1}"       )
                           break

               if "fp32" in config:
                     cmd_config.append('''--mixed_precision=no'''       )
               else:
                     cmd_config.append('''--mixed_precision=fp16'''       )

               if "cpu_offload" in config:
                     cmd_config.append('''--fsdp_offload_params=True'''       )

               for policy in FSDP_AUTO_WRAP_POLICY:
                     if policy.lower() in config:
                           cmd_config.append(F"--fsdp_auto_wrap_policy={policy}"       )
                           break

               if policy == "TRANSFORMER_BASED_WRAP":
                     cmd_config.append('''--fsdp_transformer_layer_cls_to_wrap=BertLayer'''       )
               elif policy == "SIZE_BASED_WRAP":
                     cmd_config.append('''--fsdp_min_num_params=2000'''       )

               cmd_config.extend(
                   [
                       self.test_file_path,
                       F"--output_dir={self.tmpdir}",
                       F"--performance_lower_bound={self.performance_lower_bound}",
                   ]       )
               with patch_environment(omp_num_threads=1       ):
                     execute_subprocess_async(lowerCamelCase__			,						env=os.environ.copy()       )

   def     UpperCamelCase					(				self	:    List[Any]       ) ->			Union[str, Any]:
         """simple docstring"""





         A_							       =		os.path.join(self.test_scripts_folder			,						'''test_checkpointing.py'''       )
         A_							       =		[
             '''accelerate''',
             '''launch''',
             '''--num_processes=2''',
             '''--num_machines=1''',
             '''--machine_rank=0''',
             '''--use_fsdp''',
             '''--mixed_precision=fp16''',
             '''--fsdp_transformer_layer_cls_to_wrap=BertLayer''',
         ]

         for i, strategy in enumerate(lowerCamelCase__       ):
               A_							       =		cmd.copy()
               cmd_config.append(F"--fsdp_sharding_strategy={i+1}"       )
               if strategy != "FULL_SHARD":
                     continue
               A_							       =		len(lowerCamelCase__       )
               for state_dict_type in FSDP_STATE_DICT_TYPE:
                     A_							       =		cmd_config[:state_dict_config_index]
                     cmd_config.append(F"--fsdp_state_dict_type={state_dict_type}"       )
                     cmd_config.extend(
                         [
                             self.test_file_path,
                             F"--output_dir={self.tmpdir}",
                             '''--partial_train_epoch=1''',
                         ]       )
                     with patch_environment(omp_num_threads=1       ):
                           execute_subprocess_async(lowerCamelCase__			,						env=os.environ.copy()       )

                     A_							       =		cmd_config[:-1]
                     A_							       =		os.path.join(self.tmpdir			,						'''epoch_0'''       )
                     cmd_config.extend(
                         [
                             F"--resume_from_checkpoint={resume_from_checkpoint}",
                         ]       )
                     with patch_environment(omp_num_threads=1       ):
                           execute_subprocess_async(lowerCamelCase__			,						env=os.environ.copy()       )





   def     UpperCamelCase					(				self	:    Union[str, Any]       ) ->			Any:
         """simple docstring"""





         A_							       =		os.path.join(self.test_scripts_folder			,						'''test_peak_memory_usage.py'''       )
         A_							       =		[
             '''accelerate''',
             '''launch''',
             '''--num_processes=2''',
             '''--num_machines=1''',
             '''--machine_rank=0''',
         ]
         for spec, peak_mem_upper_bound in self.peak_memory_usage_upper_bound.items():
               A_							       =		cmd.copy()
               if "fp16" in spec:
                     cmd_config.extend(['''--mixed_precision=fp16''']       )
               else:
                     cmd_config.extend(['''--mixed_precision=no''']       )

               if "multi_gpu" in spec:
                     continue
               else:
                     cmd_config.extend(['''--use_fsdp''']       )
                     for i, strategy in enumerate(lowerCamelCase__       ):
                           if strategy.lower() in spec:
                                 cmd_config.append(F"--fsdp_sharding_strategy={i+1}"       )
                                 break

                     if "cpu_offload" in spec:
                           cmd_config.append('''--fsdp_offload_params=True'''       )

                     for policy in FSDP_AUTO_WRAP_POLICY:
                           if policy.lower() in spec:
                                 cmd_config.append(F"--fsdp_auto_wrap_policy={policy}"       )
                                 break

                     if policy == "TRANSFORMER_BASED_WRAP":
                           cmd_config.append('''--fsdp_transformer_layer_cls_to_wrap=BertLayer'''       )
                     elif policy == "SIZE_BASED_WRAP":
                           cmd_config.append('''--fsdp_min_num_params=2000'''       )

               cmd_config.extend(
                   [
                       self.test_file_path,
                       F"--output_dir={self.tmpdir}",
                       F"--peak_memory_upper_bound={peak_mem_upper_bound}",
                       F"--n_train={self.n_train}",
                       F"--n_val={self.n_val}",
                   ]       )
               with patch_environment(omp_num_threads=1       ):
                     execute_subprocess_async(lowerCamelCase__			,						env=os.environ.copy()       )








from __future__ import annotations

import unittest

from transformers import DebertaVaConfig, 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 (
          TFDebertaVaForMaskedLM,
          TFDebertaVaForQuestionAnswering,
          TFDebertaVaForSequenceClassification,
          TFDebertaVaForTokenClassification,
          TFDebertaVaModel,
      )

class    _lowercase				:

   def __init__(				self	:    str			,						lowerCamelCase__	:    Dict			,						lowerCamelCase__	:    Union[str, Any]=1_3			,						lowerCamelCase__	:    Dict=7			,						lowerCamelCase__	:    List[Any]=True			,						lowerCamelCase__	:    Tuple=True			,						lowerCamelCase__	:    List[str]=True			,						lowerCamelCase__	:    List[Any]=True			,						lowerCamelCase__	:    Any=9_9			,						lowerCamelCase__	:    Union[str, Any]=3_2			,						lowerCamelCase__	:    Dict=2			,						lowerCamelCase__	:    Tuple=4			,						lowerCamelCase__	:    int=3_7			,						lowerCamelCase__	:    List[str]="gelu"			,						lowerCamelCase__	:    str=0.1			,						lowerCamelCase__	:    Any=0.1			,						lowerCamelCase__	:    int=5_1_2			,						lowerCamelCase__	:    Optional[Any]=1_6			,						lowerCamelCase__	:    Optional[Any]=2			,						lowerCamelCase__	:    List[str]=0.02			,						lowerCamelCase__	:    Dict=False			,						lowerCamelCase__	:    Union[str, Any]=True			,						lowerCamelCase__	:    List[Any]="None"			,						lowerCamelCase__	:    int=3			,						lowerCamelCase__	:    List[Any]=4			,						lowerCamelCase__	:    List[str]=None			,						) ->			List[str]:
         """simple docstring"""





         A_							       =		parent
         A_							       =		batch_size
         A_							       =		seq_length
         A_							       =		is_training
         A_							       =		use_input_mask
         A_							       =		use_token_type_ids
         A_							       =		use_labels
         A_							       =		vocab_size
         A_							       =		hidden_size
         A_							       =		num_hidden_layers
         A_							       =		num_attention_heads
         A_							       =		intermediate_size
         A_							       =		hidden_act
         A_							       =		hidden_dropout_prob
         A_							       =		attention_probs_dropout_prob
         A_							       =		max_position_embeddings
         A_							       =		type_vocab_size
         A_							       =		type_sequence_label_size
         A_							       =		initializer_range
         A_							       =		num_labels
         A_							       =		num_choices
         A_							       =		relative_attention
         A_							       =		position_biased_input
         A_							       =		pos_att_type
         A_							       =		scope

   def     UpperCamelCase					(				self	:    str       ) ->			str:
         """simple docstring"""





         A_							       =		ids_tensor([self.batch_size, self.seq_length]			,						self.vocab_size       )

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

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

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

         A_							       =		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			,						relative_attention=self.relative_attention			,						position_biased_input=self.position_biased_input			,						initializer_range=self.initializer_range			,						return_dict=lowerCamelCase__			,						)

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

   def     UpperCamelCase					(				self	:    Tuple			,						lowerCamelCase__	:    Union[str, Any]			,						lowerCamelCase__	:    Dict			,						lowerCamelCase__	:    Dict			,						lowerCamelCase__	:    Union[str, Any]			,						lowerCamelCase__	:    List[Any]			,						lowerCamelCase__	:    Union[str, Any]			,						lowerCamelCase__	:    Union[str, Any]       ) ->			Any:
         """simple docstring"""





         A_							       =		TFDebertaVaModel(config=lowerCamelCase__       )
         A_							       =		{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

         A_							       =		[input_ids, input_mask]
         A_							       =		model(lowerCamelCase__       )

         A_							       =		model(lowerCamelCase__       )

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

   def     UpperCamelCase					(				self	:    Tuple			,						lowerCamelCase__	:    Optional[int]			,						lowerCamelCase__	:    int			,						lowerCamelCase__	:    Optional[int]			,						lowerCamelCase__	:    Tuple			,						lowerCamelCase__	:    Union[str, Any]			,						lowerCamelCase__	:    Dict			,						lowerCamelCase__	:    List[str]       ) ->			str:
         """simple docstring"""





         A_							       =		TFDebertaVaForMaskedLM(config=lowerCamelCase__       )
         A_							       =		{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }
         A_							       =		model(lowerCamelCase__       )
         self.parent.assertEqual(result.logits.shape			,						(self.batch_size, self.seq_length, self.vocab_size)       )

   def     UpperCamelCase					(				self	:    Any			,						lowerCamelCase__	:    str			,						lowerCamelCase__	:    int			,						lowerCamelCase__	:    Optional[int]			,						lowerCamelCase__	:    Union[str, Any]			,						lowerCamelCase__	:    Dict			,						lowerCamelCase__	:    List[Any]			,						lowerCamelCase__	:    Tuple       ) ->			List[Any]:
         """simple docstring"""





         A_							       =		self.num_labels
         A_							       =		TFDebertaVaForSequenceClassification(config=lowerCamelCase__       )
         A_							       =		{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }

         A_							       =		model(lowerCamelCase__       )
         self.parent.assertEqual(result.logits.shape			,						(self.batch_size, self.num_labels)       )

   def     UpperCamelCase					(				self	:    str			,						lowerCamelCase__	:    Tuple			,						lowerCamelCase__	:    Dict			,						lowerCamelCase__	:    str			,						lowerCamelCase__	:    int			,						lowerCamelCase__	:    Any			,						lowerCamelCase__	:    Tuple			,						lowerCamelCase__	:    str       ) ->			Optional[Any]:
         """simple docstring"""





         A_							       =		self.num_labels
         A_							       =		TFDebertaVaForTokenClassification(config=lowerCamelCase__       )
         A_							       =		{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }
         A_							       =		model(lowerCamelCase__       )
         self.parent.assertEqual(result.logits.shape			,						(self.batch_size, self.seq_length, self.num_labels)       )

   def     UpperCamelCase					(				self	:    Tuple			,						lowerCamelCase__	:    int			,						lowerCamelCase__	:    Any			,						lowerCamelCase__	:    Any			,						lowerCamelCase__	:    Optional[Any]			,						lowerCamelCase__	:    Tuple			,						lowerCamelCase__	:    str			,						lowerCamelCase__	:    Any       ) ->			Any:
         """simple docstring"""





         A_							       =		TFDebertaVaForQuestionAnswering(config=lowerCamelCase__       )
         A_							       =		{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }

         A_							       =		model(lowerCamelCase__       )
         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       ) ->			Optional[int]:
         """simple docstring"""





         A_							       =		self.prepare_config_and_inputs()
         (
             (
             A_
         )       ,(
             A_
         )       ,(
             A_
         )       ,(
             A_
         )       ,(
             A_
         )       ,(
             A_
         )       ,(
             A_
         )       ,
         )							       =		config_and_inputs
         A_							       =		{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
         return config, inputs_dict



@require_tf
class    _lowercase				(					__lowerCamelCase,__lowerCamelCase,unittest.TestCase			):
   _lowercase     :       Union[str, Any]  					=    (
       (
           TFDebertaVaModel,
           TFDebertaVaForMaskedLM,
           TFDebertaVaForQuestionAnswering,
           TFDebertaVaForSequenceClassification,
           TFDebertaVaForTokenClassification,
       )
       if is_tf_available()
       else ()
   )
   _lowercase     :       Optional[Any]  					=    (
       {
           'feature-extraction': TFDebertaVaModel,
           'fill-mask': TFDebertaVaForMaskedLM,
           'question-answering': TFDebertaVaForQuestionAnswering,
           'text-classification': TFDebertaVaForSequenceClassification,
           'token-classification': TFDebertaVaForTokenClassification,
           'zero-shot': TFDebertaVaForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )

   _lowercase     :       List[str]  					=    False
   _lowercase     :       Any  					=    False

   def     UpperCamelCase					(				self	:    int       ) ->			List[str]:
         """simple docstring"""





         A_							       =		TFDebertaVaModelTester(self       )
         A_							       =		ConfigTester(self			,						config_class=lowerCamelCase__			,						hidden_size=3_7       )

   def     UpperCamelCase					(				self	:    Optional[Any]       ) ->			Optional[Any]:
         """simple docstring"""





         self.config_tester.run_common_tests()

   def     UpperCamelCase					(				self	:    Any       ) ->			List[Any]:
         """simple docstring"""





         A_							       =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCamelCase__       )

   def     UpperCamelCase					(				self	:    Any       ) ->			Optional[int]:
         """simple docstring"""





         A_							       =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase__       )

   def     UpperCamelCase					(				self	:    Any       ) ->			List[str]:
         """simple docstring"""





         A_							       =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*lowerCamelCase__       )

   def     UpperCamelCase					(				self	:    List[Any]       ) ->			Dict:
         """simple docstring"""





         A_							       =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*lowerCamelCase__       )

   def     UpperCamelCase					(				self	:    Any       ) ->			List[str]:
         """simple docstring"""





         A_							       =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*lowerCamelCase__       )





   @slow
   def     UpperCamelCase					(				self	:    Union[str, Any]       ) ->			int:
         """simple docstring"""





         A_							       =		TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge'''       )
         self.assertIsNotNone(lowerCamelCase__       )



@require_tf
class    _lowercase				(					unittest.TestCase			):

   @unittest.skip(reason='''Model not available yet'''       )
   def     UpperCamelCase					(				self	:    Tuple       ) ->			List[str]:
         """simple docstring"""





         pass





   @slow
   def     UpperCamelCase					(				self	:    Any       ) ->			Any:
         """simple docstring"""





         A_							       =		TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge'''       )
         A_							       =		tf.constant([[0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 4_6_0_7_8, 1_5_8_8, 2]]       )
         A_							       =		tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]       )
         A_							       =		model(lowerCamelCase__			,						attention_mask=lowerCamelCase__       )[0]

         A_							       =		tf.constant(
             [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]]       )
         tf.debugging.assert_near(output[:, 1:4, 1:4]			,						lowerCamelCase__			,						atol=1e-4       )





