



"""simple docstring"""


# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import copy
import importlib.metadata
import json
import os
from dataclasses import dataclass
from typing import Any, Dict, Union

from packaging import version

from ..utils import is_torch_available, logging


if is_torch_available():
				import torch


snake_case_    					=	logging.get_logger(__name__)







@dataclass
class 				A_      :



						"""simple docstring"""






						def __init__( self			:str       ,  lowercase_			:Optional[int]=False       ,  lowercase_			:Optional[Any]=False       ,  lowercase_			:str=6.0       ,  lowercase_			:Optional[Any]=None       ,  lowercase_			:Any=False       ,  lowercase_			:int=False       ,  lowercase_			:Tuple=None       ,  lowercase_			:str="fp4"       ,  lowercase_			:Optional[int]=False       ,  **lowercase_			:Any       ,  )    ->      Dict:
												UpperCAmelCase					=			load_in_abit
												UpperCAmelCase					=			load_in_abit
												UpperCAmelCase					=			llm_inta_threshold
												UpperCAmelCase					=			llm_inta_skip_modules
												UpperCAmelCase					=			llm_inta_enable_fpaa_cpu_offload
												UpperCAmelCase					=			llm_inta_has_fpaa_weight
												UpperCAmelCase					=			bnb_abit_quant_type
												UpperCAmelCase					=			bnb_abit_use_double_quant

												if bnb_abit_compute_dtype is None:
																		UpperCAmelCase					=			torch.floataa
												elif isinstance(lowercase_       ,  lowercase_ ):
																		UpperCAmelCase					=			getattr(lowercase_       ,  lowercase_ )
												elif isinstance(lowercase_       ,  torch.dtype ):
																		UpperCAmelCase					=			bnb_abit_compute_dtype
												else:
																		raise ValueError('bnb_4bit_compute_dtype must be a string or a torch.dtype' )

												self.post_init()






						def      UpperCAmelCase__					( self			:Any )    ->      Any:
												if not isinstance(self.llm_inta_threshold       ,  lowercase_ ):
																		raise ValueError('llm_int8_threshold must be a float' )

												if self.llm_inta_skip_modules is not None and not isinstance(self.llm_inta_skip_modules       ,  lowercase_ ):
																		raise ValueError('llm_int8_skip_modules must be a list of strings' )
												if not isinstance(self.llm_inta_enable_fpaa_cpu_offload       ,  lowercase_ ):
																		raise ValueError('llm_int8_enable_fp32_cpu_offload must be a boolean' )

												if not isinstance(self.llm_inta_has_fpaa_weight       ,  lowercase_ ):
																		raise ValueError('llm_int8_has_fp16_weight must be a boolean' )

												if self.bnb_abit_compute_dtype is not None and not isinstance(self.bnb_abit_compute_dtype       ,  torch.dtype ):
																		raise ValueError('bnb_4bit_compute_dtype must be torch.dtype' )

												if not isinstance(self.bnb_abit_quant_type       ,  lowercase_ ):
																		raise ValueError('bnb_4bit_quant_type must be a string' )

												if not isinstance(self.bnb_abit_use_double_quant       ,  lowercase_ ):
																		raise ValueError('bnb_4bit_use_double_quant must be a boolean' )

												if self.load_in_abit and not version.parse(importlib.metadata.version('bitsandbytes' ) ) >= version.parse(
												    '0.39.0' ):
																		raise ValueError(
																		    '4 bit quantization requires bitsandbytes>=0.39.0 - please upgrade your bitsandbytes version' )






						def      UpperCAmelCase__					( self			:Dict )    ->      Tuple:
												return self.load_in_abit or self.load_in_abit






						def      UpperCAmelCase__					( self			:Any )    ->      Any:
												if self.load_in_abit:
																		return "llm_int8"
												elif self.load_in_abit and self.bnb_abit_quant_type == "fp4":
																		return "fp4"
												elif self.load_in_abit and self.bnb_abit_quant_type == "nf4":
																		return "nf4"
												else:
																		return None






						@classmethod
						def      UpperCAmelCase__					( cls			:List[str]       ,  lowercase_			:int       ,  lowercase_			:Optional[Any]       ,  **lowercase_			:Union[str, Any] )    ->      Optional[int]:
												UpperCAmelCase					=			cls(**lowercase_ )

												UpperCAmelCase					=			[]
												for key, value in kwargs.items():
																		if hasattr(lowercase_       ,  lowercase_ ):
																								setattr(lowercase_       ,  lowercase_       ,  lowercase_ )
																								to_remove.append(lowercase_ )
												for key in to_remove:
																		kwargs.pop(lowercase_       ,  lowercase_ )

												if return_unused_kwargs:
																		return config, kwargs
												else:
																		return config






						def      UpperCAmelCase__					( self			:str       ,  lowercase_			:Union[str, os.PathLike] )    ->      Any:
												with open(lowercase_       ,  'w'       ,  encoding='utf-8' ) as writer:
																		UpperCAmelCase					=			self.to_dict()
																		UpperCAmelCase					=			json.dumps(lowercase_       ,  indent=2       ,  sort_keys=lowercase_ ) + '\n'

																		writer.write(lowercase_ )






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Dict[str, Any]:
												UpperCAmelCase					=			copy.deepcopy(self.__dict__ )
												UpperCAmelCase					=			str(output['bnb_4bit_compute_dtype'] ).split('.' )[1]

												return output






						def __repr__( self			:Union[str, Any] )    ->      int:
												return f"""{self.__class__.__name__} {self.to_json_string()}"""






						def      UpperCAmelCase__					( self			:Optional[Any]       ,  lowercase_			:bool = True )    ->      str:
												if use_diff is True:
																		UpperCAmelCase					=			self.to_diff_dict()
												else:
																		UpperCAmelCase					=			self.to_dict()
												return json.dumps(lowercase_       ,  indent=2       ,  sort_keys=lowercase_ ) + "\n"






						def      UpperCAmelCase__					( self			:Union[str, Any] )    ->      Dict[str, Any]:
												UpperCAmelCase					=			self.to_dict()

												# get the default config dict
												UpperCAmelCase					=			BitsAndBytesConfig().to_dict()

												UpperCAmelCase					=			{}

												# only serialize values that differ from the default config
												for key, value in config_dict.items():
																		if value != default_config_dict[key]:
																								UpperCAmelCase					=			value

												return serializable_config_dict










"""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 				A_      (					SCREAMING_SNAKE_CASE_    ):



						"""simple docstring"""






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






						def      UpperCAmelCase__					( self			:Any )    ->      Tuple:
												UpperCAmelCase					=			ids_tensor([self.batch_size, self.seq_length]       ,  self.vocab_size )

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

												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					=			self.get_config()

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






						def      UpperCAmelCase__					( self			:Tuple )    ->      Tuple:
												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      UpperCAmelCase__					( self			:Optional[int]       ,  lowercase_			:str )    ->      List[str]:
												self.parent.assertListEqual(list(result.loss.size() )       ,  [] )






						def      UpperCAmelCase__					( self			:Optional[int]       ,  lowercase_			:str       ,  lowercase_			:Tuple       ,  lowercase_			:str       ,  lowercase_			:int       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:List[str]       ,  lowercase_			:Optional[int] )    ->      Optional[int]:
												UpperCAmelCase					=			DebertaVaModel(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_ )[0]
												UpperCAmelCase					=			model(lowercase_       ,  token_type_ids=lowercase_ )[0]
												UpperCAmelCase					=			model(lowercase_ )[0]

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






						def      UpperCAmelCase__					( self			:Optional[Any]       ,  lowercase_			:Dict       ,  lowercase_			:List[str]       ,  lowercase_			:Any       ,  lowercase_			:List[str]       ,  lowercase_			:Tuple       ,  lowercase_			:List[Any]       ,  lowercase_			:int )    ->      Any:
												UpperCAmelCase					=			DebertaVaForMaskedLM(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_ )

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






						def      UpperCAmelCase__					( self			:Union[str, Any]       ,  lowercase_			:Any       ,  lowercase_			:List[Any]       ,  lowercase_			:Any       ,  lowercase_			:Dict       ,  lowercase_			:str       ,  lowercase_			:List[Any]       ,  lowercase_			:Dict )    ->      Union[str, Any]:
												UpperCAmelCase					=			self.num_labels
												UpperCAmelCase					=			DebertaVaForSequenceClassification(lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_ )
												self.parent.assertListEqual(list(result.logits.size() )       ,  [self.batch_size, self.num_labels] )
												self.check_loss_output(lowercase_ )






						def      UpperCAmelCase__					( self			:Any       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Dict       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Any       ,  lowercase_			:Optional[int]       ,  lowercase_			:Optional[Any]       ,  lowercase_			:Any )    ->      List[Any]:
												UpperCAmelCase					=			self.num_labels
												UpperCAmelCase					=			DebertaVaForTokenClassification(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_ )
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.seq_length, self.num_labels) )






						def      UpperCAmelCase__					( self			:Any       ,  lowercase_			:Any       ,  lowercase_			:List[Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Dict       ,  lowercase_			:List[Any]       ,  lowercase_			:Optional[int] )    ->      Dict:
												UpperCAmelCase					=			DebertaVaForQuestionAnswering(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(
												    lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  start_positions=lowercase_       ,  end_positions=lowercase_       ,  )
												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			:Optional[int]       ,  lowercase_			:str       ,  lowercase_			:List[Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:List[Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Any       ,  lowercase_			:Any )    ->      List[Any]:
												UpperCAmelCase					=			DebertaVaForMultipleChoice(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			input_ids.unsqueeze(1 ).expand(-1       ,  self.num_choices       ,  -1 ).contiguous()
												UpperCAmelCase					=			token_type_ids.unsqueeze(1 ).expand(-1       ,  self.num_choices       ,  -1 ).contiguous()
												UpperCAmelCase					=			input_mask.unsqueeze(1 ).expand(-1       ,  self.num_choices       ,  -1 ).contiguous()
												UpperCAmelCase					=			model(
												    lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_       ,  )
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.num_choices) )






						def      UpperCAmelCase__					( self			:Dict )    ->      int:
												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_torch
class 				A_      (					SCREAMING_SNAKE_CASE_     ,       SCREAMING_SNAKE_CASE_     ,       unittest.TestCase    ):



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

						__UpperCamelCase		    =							True
						__UpperCamelCase		    =							False
						__UpperCamelCase		    =							False
						__UpperCamelCase		    =							False
						__UpperCamelCase		    =							False






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Optional[int]:
												UpperCAmelCase					=			DebertaVaModelTester(self )
												UpperCAmelCase					=			ConfigTester(self       ,  config_class=lowercase_       ,  hidden_size=37 )






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






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Tuple:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_model(*lowercase_ )






						def      UpperCAmelCase__					( self			:Any )    ->      List[str]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_sequence_classification(*lowercase_ )






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      List[Any]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_masked_lm(*lowercase_ )






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Optional[int]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_question_answering(*lowercase_ )






						def      UpperCAmelCase__					( self			:Union[str, Any] )    ->      Tuple:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_token_classification(*lowercase_ )






						def      UpperCAmelCase__					( self			:Any )    ->      Union[str, Any]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_multiple_choice(*lowercase_ )






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







@require_torch
@require_sentencepiece
@require_tokenizers
class 				A_      (					unittest.TestCase    ):



						"""simple docstring"""






						@unittest.skip(reason='Model not available yet' )
						def      UpperCAmelCase__					( self			:str )    ->      Tuple:
												pass






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

												UpperCAmelCase					=			torch.tensor([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]] )
												UpperCAmelCase					=			torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
												with torch.no_grad():
																		UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_ )[0]
												# compare the actual values for a slice.
												UpperCAmelCase					=			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]       ,  lowercase_       ,  atol=1E-4 )       ,  f"""{output[:, 1:4, 1:4]}""" )





