
import unittest

from transformers import ElectraConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
							import torch

							from transformers import (
							    MODEL_FOR_PRETRAINING_MAPPING,
							    ElectraForCausalLM,
							    ElectraForMaskedLM,
							    ElectraForMultipleChoice,
							    ElectraForPreTraining,
							    ElectraForQuestionAnswering,
							    ElectraForSequenceClassification,
							    ElectraForTokenClassification,
							    ElectraModel,
							)
							from transformers.models.electra.modeling_electra import ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST

class 					A_			:



							"""simple docstring"""






							def __init__(						self						:List[str]  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:List[Any]=13  ,							lowerCamelCase_						:int=7  ,							lowerCamelCase_						:Any=True  ,							lowerCamelCase_						:Dict=True  ,							lowerCamelCase_						:Union[str, Any]=True  ,							lowerCamelCase_						:Any=True  ,							lowerCamelCase_						:Union[str, Any]=99  ,							lowerCamelCase_						:int=32  ,							lowerCamelCase_						:Optional[Any]=5  ,							lowerCamelCase_						:List[Any]=4  ,							lowerCamelCase_						:str=37  ,							lowerCamelCase_						:Any="gelu"  ,							lowerCamelCase_						:Optional[int]=0.1  ,							lowerCamelCase_						:Union[str, Any]=0.1  ,							lowerCamelCase_						:str=512  ,							lowerCamelCase_						:Any=16  ,							lowerCamelCase_						:Optional[int]=2  ,							lowerCamelCase_						:int=0.02  ,							lowerCamelCase_						:Tuple=3  ,							lowerCamelCase_						:Dict=4  ,							lowerCamelCase_						:Optional[int]=None  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Union[str, Any]  =parent
										lowerCamelCase__			:  List[Any]  =batch_size
										lowerCamelCase__			:  List[Any]  =seq_length
										lowerCamelCase__			:  Tuple  =is_training
										lowerCamelCase__			:  Dict  =use_input_mask
										lowerCamelCase__			:  Any  =use_token_type_ids
										lowerCamelCase__			:  str  =use_labels
										lowerCamelCase__			:  Optional[int]  =vocab_size
										lowerCamelCase__			:  Optional[int]  =hidden_size
										lowerCamelCase__			:  Any  =num_hidden_layers
										lowerCamelCase__			:  str  =num_attention_heads
										lowerCamelCase__			:  Any  =intermediate_size
										lowerCamelCase__			:  Tuple  =hidden_act
										lowerCamelCase__			:  List[str]  =hidden_dropout_prob
										lowerCamelCase__			:  List[Any]  =attention_probs_dropout_prob
										lowerCamelCase__			:  Optional[int]  =max_position_embeddings
										lowerCamelCase__			:  Union[str, Any]  =type_vocab_size
										lowerCamelCase__			:  Union[str, Any]  =type_sequence_label_size
										lowerCamelCase__			:  Optional[int]  =initializer_range
										lowerCamelCase__			:  Optional[Any]  =num_labels
										lowerCamelCase__			:  Any  =num_choices
										lowerCamelCase__			:  Optional[int]  =scope





							def    UpperCAmelCase__							(						self						:Optional[int] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =ids_tensor([self.batch_size, self.seq_length]  ,							self.vocab_size )

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

										lowerCamelCase__			:  int  =None
										if self.use_token_type_ids:
													lowerCamelCase__			:  Union[str, Any]  =ids_tensor([self.batch_size, self.seq_length]  ,							self.type_vocab_size )

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

										lowerCamelCase__			:  List[Any]  =self.get_config()

										return (
										    config,
										    input_ids,
										    token_type_ids,
										    input_mask,
										    sequence_labels,
										    token_labels,
										    choice_labels,
										    fake_token_labels,
										)





							def    UpperCAmelCase__							(						self						:Optional[Any] ):





										"""simple docstring"""

										return ElectraConfig(
										    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  ,							is_decoder=lowerCamelCase_  ,							initializer_range=self.initializer_range  ,							)





							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										(
										    lowerCamelCase__       
										)			:  List[str]  =self.prepare_config_and_inputs()

										lowerCamelCase__			:  Union[str, Any]  =True
										lowerCamelCase__			:  Optional[int]  =floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
										lowerCamelCase__			:  Dict  =ids_tensor([self.batch_size, self.seq_length]  ,							vocab_size=2 )

										return (
										    config,
										    input_ids,
										    token_type_ids,
										    input_mask,
										    sequence_labels,
										    token_labels,
										    choice_labels,
										    encoder_hidden_states,
										    encoder_attention_mask,
										)





							def    UpperCAmelCase__							(						self						:Optional[Any]  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:List[Any]  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:int  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:int  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:str  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Optional[Any]  =ElectraModel(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  int  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_ )
										lowerCamelCase__			:  Union[str, Any]  =model(lowerCamelCase_  ,							token_type_ids=lowerCamelCase_ )
										lowerCamelCase__			:  Optional[Any]  =model(lowerCamelCase_ )
										self.parent.assertEqual(result.last_hidden_state.shape  ,							(self.batch_size, self.seq_length, self.hidden_size) )





							def    UpperCAmelCase__							(						self						:Optional[Any]  ,							lowerCamelCase_						:Union[str, Any]  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:Union[str, Any]  ,							lowerCamelCase_						:List[Any]  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Union[str, Any]  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =True
										lowerCamelCase__			:  Any  =ElectraModel(lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Any  =model(
										    lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							encoder_hidden_states=lowerCamelCase_  ,							encoder_attention_mask=lowerCamelCase_  ,							)
										lowerCamelCase__			:  Union[str, Any]  =model(
										    lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							encoder_hidden_states=lowerCamelCase_  ,							)
										lowerCamelCase__			:  Dict  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_ )
										self.parent.assertEqual(result.last_hidden_state.shape  ,							(self.batch_size, self.seq_length, self.hidden_size) )





							def    UpperCAmelCase__							(						self						:Optional[Any]  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:int  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:Any  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  int  =ElectraForMaskedLM(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Union[str, Any]  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							labels=lowerCamelCase_ )
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.seq_length, self.vocab_size) )





							def    UpperCAmelCase__							(						self						:Tuple  ,							lowerCamelCase_						:int  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:List[Any]  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  List[Any]  =ElectraForCausalLM(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Any  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							labels=lowerCamelCase_ )
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.seq_length, self.vocab_size) )





							def    UpperCAmelCase__							(						self						:str  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:Tuple  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  List[Any]  =self.num_labels
										lowerCamelCase__			:  List[str]  =ElectraForTokenClassification(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Optional[int]  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							labels=lowerCamelCase_ )
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.seq_length, self.num_labels) )





							def    UpperCAmelCase__							(						self						:int  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:Union[str, Any]  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Optional[int]  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =self.num_labels
										lowerCamelCase__			:  str  =ElectraForPreTraining(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Any  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							labels=lowerCamelCase_ )
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.seq_length) )





							def    UpperCAmelCase__							(						self						:Union[str, Any]  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:List[Any]  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:Tuple  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Tuple  =self.num_labels
										lowerCamelCase__			:  Optional[Any]  =ElectraForSequenceClassification(lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Dict  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							labels=lowerCamelCase_ )
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.num_labels) )





							def    UpperCAmelCase__							(						self						:List[str]  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:int  ,							lowerCamelCase_						:Dict  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =ElectraForQuestionAnswering(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  int  =model(
										    lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							start_positions=lowerCamelCase_  ,							end_positions=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						:List[Any]  ,							lowerCamelCase_						:Union[str, Any]  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Union[str, Any]  ,							lowerCamelCase_						:Union[str, Any]  ,							lowerCamelCase_						:List[Any]  ,							lowerCamelCase_						:List[Any]  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  List[Any]  =self.num_choices
										lowerCamelCase__			:  Union[str, Any]  =ElectraForMultipleChoice(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  str  =input_ids.unsqueeze(1 ).expand(-1  ,							self.num_choices  ,							-1 ).contiguous()
										lowerCamelCase__			:  int  =token_type_ids.unsqueeze(1 ).expand(-1  ,							self.num_choices  ,							-1 ).contiguous()
										lowerCamelCase__			:  int  =input_mask.unsqueeze(1 ).expand(-1  ,							self.num_choices  ,							-1 ).contiguous()
										lowerCamelCase__			:  str  =model(
										    lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							labels=lowerCamelCase_  ,							)
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.num_choices) )





							def    UpperCAmelCase__							(						self						:str ):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =self.prepare_config_and_inputs()
										(
										    lowerCamelCase__       
										)			:  List[str]  =config_and_inputs
										lowerCamelCase__			:  Optional[Any]  ={'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
										return config, inputs_dict






@require_torch
class 					A_			(  A__   ,      A__   ,      unittest.TestCase     ):



							"""simple docstring"""






							SCREAMING_SNAKE_CASE_			   =     (
							    (
							        ElectraModel,
							        ElectraForPreTraining,
							        ElectraForMaskedLM,
							        ElectraForCausalLM,
							        ElectraForMultipleChoice,
							        ElectraForTokenClassification,
							        ElectraForSequenceClassification,
							        ElectraForQuestionAnswering,
							    )
							    if is_torch_available()
							    else ()
							)
							SCREAMING_SNAKE_CASE_			   =     (
							    {
							        """feature-extraction""": ElectraModel,
							        """fill-mask""": ElectraForMaskedLM,
							        """question-answering""": ElectraForQuestionAnswering,
							        """text-classification""": ElectraForSequenceClassification,
							        """text-generation""": ElectraForCausalLM,
							        """token-classification""": ElectraForTokenClassification,
							        """zero-shot""": ElectraForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							SCREAMING_SNAKE_CASE_			   =     True





							def    UpperCAmelCase__							(						self						:List[Any]  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:List[Any]=False ):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =super()._prepare_for_class(lowerCamelCase_  ,							lowerCamelCase_  ,							return_labels=lowerCamelCase_ )

										if return_labels:
													if model_class in get_values(lowerCamelCase_ ):
																lowerCamelCase__			:  int  =torch.zeros(
																    (self.model_tester.batch_size, self.model_tester.seq_length)  ,							dtype=torch.long  ,							device=lowerCamelCase_ )
										return inputs_dict





							def    UpperCAmelCase__							(						self						:Optional[int] ):





										"""simple docstring"""

										lowerCamelCase__			:  Any  =ElectraModelTester(self )
										lowerCamelCase__			:  Tuple  =ConfigTester(self  ,							config_class=lowerCamelCase_  ,							hidden_size=37 )





							def    UpperCAmelCase__							(						self						:str ):





										"""simple docstring"""

										self.config_tester.run_common_tests()





							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_model(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:Union[str, Any] ):





										"""simple docstring"""

										lowerCamelCase__			:  int  =self.model_tester.prepare_config_and_inputs_for_decoder()
										self.model_tester.create_and_check_electra_model_as_decoder(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:Tuple ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
													lowerCamelCase__			:  List[Any]  =type
													self.model_tester.create_and_check_electra_model(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_masked_lm(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_token_classification(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:Dict ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_pretraining(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:Dict ):





										"""simple docstring"""

										lowerCamelCase__			:  Any  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_sequence_classification(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:Any ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_question_answering(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_multiple_choice(*lowerCamelCase_ )





							@slow
							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													lowerCamelCase__			:  List[str]  =ElectraModel.from_pretrained(lowerCamelCase_ )
													self.assertIsNotNone(lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs_for_decoder()
										self.model_tester.create_and_check_electra_for_causal_lm(*lowerCamelCase_ )






@require_torch
class 					A_			(  unittest.TestCase     ):



							"""simple docstring"""






							@slow
							def    UpperCAmelCase__							(						self						:Optional[Any] ):





										"""simple docstring"""

										lowerCamelCase__			:  int  =ElectraModel.from_pretrained('google/electra-small-discriminator' )
										lowerCamelCase__			:  Any  =torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]] )
										lowerCamelCase__			:  Optional[Any]  =torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
										lowerCamelCase__			:  Optional[int]  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_ )[0]
										lowerCamelCase__			:  Tuple  =torch.Size((1, 11, 256) )
										self.assertEqual(output.shape  ,							lowerCamelCase_ )
										lowerCamelCase__			:  Any  =torch.tensor(
										    [[[0.44_71, 0.68_21, -0.32_65], [0.46_27, 0.52_55, -0.36_68], [0.45_32, 0.33_13, -0.43_44]]] )

										self.assertTrue(torch.allclose(output[:, 1:4, 1:4]  ,							lowerCamelCase_  ,							atol=1e-4 ) )

"""simple docstring"""


import inspect
import os
from argparse import ArgumentParser, Namespace
from importlib import import_module

import huggingface_hub
import numpy as np
from packaging import version

from .. import (
    FEATURE_EXTRACTOR_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoImageProcessor,
    AutoProcessor,
    AutoTokenizer,
    is_datasets_available,
    is_tf_available,
    is_torch_available,
)
from ..utils import TF2_WEIGHTS_INDEX_NAME, TF2_WEIGHTS_NAME, logging
from . import BaseTransformersCLICommand


if is_tf_available():
							import tensorflow as tf

							tf.config.experimental.enable_tensor_float_aa_execution(False)

if is_torch_available():
							import torch

if is_datasets_available():
							from datasets import load_dataset


lowerCAmelCase			=		5E-5  # larger error tolerance than in our internal tests, to avoid flaky user-facing errors






def      lowerCAmelCase_     (	snake_case_	:    Namespace    )     ->Optional[int]:
			return PTtoTFCommand(
			    args.model_name							,					args.local_dir							,					args.max_error							,					args.new_weights							,					args.no_pr							,					args.push							,					args.extra_commit_description							,					args.override_model_class							,					)

class 					A_			(  A__     ):



							"""simple docstring"""






							@staticmethod
							def    UpperCAmelCase__							(						lowerCamelCase_						:ArgumentParser ):





										"""simple docstring"""

										lowerCamelCase__			:  Tuple  =parser.add_parser(
										    'pt-to-tf'  ,							help=(
										        'CLI tool to run convert a transformers model from a PyTorch checkpoint to a TensorFlow checkpoint.'
										        ' Can also be used to validate existing weights without opening PRs, with --no-pr.'
										    )  ,							)
										train_parser.add_argument(
										    '--model-name'  ,							type=lowerCamelCase_  ,							required=lowerCamelCase_  ,							help='The model name, including owner/organization, as seen on the hub.'  ,							)
										train_parser.add_argument(
										    '--local-dir'  ,							type=lowerCamelCase_  ,							default=''  ,							help='Optional local directory of the model repository. Defaults to /tmp/{model_name}'  ,							)
										train_parser.add_argument(
										    '--max-error'  ,							type=lowerCamelCase_  ,							default=lowerCamelCase_  ,							help=(
										        f"""Maximum error tolerance. Defaults to {MAX_ERROR}. This flag should be avoided, use at your own risk."""
										    )  ,							)
										train_parser.add_argument(
										    '--new-weights'  ,							action='store_true'  ,							help='Optional flag to create new TensorFlow weights, even if they already exist.'  ,							)
										train_parser.add_argument(
										    '--no-pr'  ,							action='store_true'  ,							help='Optional flag to NOT open a PR with converted weights.' )
										train_parser.add_argument(
										    '--push'  ,							action='store_true'  ,							help='Optional flag to push the weights directly to `main` (requires permissions)'  ,							)
										train_parser.add_argument(
										    '--extra-commit-description'  ,							type=lowerCamelCase_  ,							default=''  ,							help='Optional additional commit description to use when opening a PR (e.g. to tag the owner).'  ,							)
										train_parser.add_argument(
										    '--override-model-class'  ,							type=lowerCamelCase_  ,							default=lowerCamelCase_  ,							help='If you think you know better than the auto-detector, you can specify the model class here. '
										    'Can be either an AutoModel class or a specific model class like BertForSequenceClassification.'  ,							)
										train_parser.set_defaults(func=lowerCamelCase_ )





							@staticmethod
							def    UpperCAmelCase__							(						lowerCamelCase_						:int  ,							lowerCamelCase_						:Optional[Any] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =set(pt_outputs.keys() )
										lowerCamelCase__			:  Union[str, Any]  =set(tf_outputs.keys() )
										if pt_out_attrs != tf_out_attrs:
													raise ValueError(
													    f"""The model outputs have different attributes, aborting. (Pytorch: {pt_out_attrs}, TensorFlow:"""
													    f""" {tf_out_attrs})""" )

										# 2. For each output attribute, computes the difference
										def _find_pt_tf_differences(lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Tuple="" ):
													# If the current attribute is a tensor, it is a leaf and we make the comparison. Otherwise, we will dig in
													# recursivelly, keeping the name of the attribute.
													if isinstance(lowerCamelCase_  ,							torch.Tensor ):
																lowerCamelCase__			:  List[str]  =np.max(np.abs(pt_out.numpy() - tf_out.numpy() ) )
																lowerCamelCase__			:  Dict  =tensor_difference
													else:
																lowerCamelCase__			:  List[str]  =attr_name
																for i, pt_item in enumerate(lowerCamelCase_ ):
																			# If it is a named attribute, we keep the name. Otherwise, just its index.
																			if isinstance(lowerCamelCase_  ,							lowerCamelCase_ ):
																						lowerCamelCase__			:  str  =root_name + pt_item
																						lowerCamelCase__			:  List[Any]  =tf_out[pt_item]
																						lowerCamelCase__			:  str  =pt_out[pt_item]
																			else:
																						lowerCamelCase__			:  Union[str, Any]  =root_name + f"""[{i}]"""
																						lowerCamelCase__			:  Tuple  =tf_out[i]
																			lowerCamelCase__			:  Any  =_find_pt_tf_differences(lowerCamelCase_  ,							lowerCamelCase_  ,							lowerCamelCase_  ,							lowerCamelCase_ )

													return differences

										return _find_pt_tf_differences(lowerCamelCase_  ,							lowerCamelCase_  ,							{} )





							def __init__(						self						:Union[str, Any]  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:float  ,							lowerCamelCase_						:bool  ,							lowerCamelCase_						:bool  ,							lowerCamelCase_						:bool  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:str  ,							*lowerCamelCase_						:Union[str, Any]  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =logging.get_logger('transformers-cli/pt_to_tf' )
										lowerCamelCase__			:  List[str]  =model_name
										lowerCamelCase__			:  str  =local_dir if local_dir else os.path.join('/tmp'  ,							lowerCamelCase_ )
										lowerCamelCase__			:  Dict  =max_error
										lowerCamelCase__			:  Union[str, Any]  =new_weights
										lowerCamelCase__			:  Optional[Any]  =no_pr
										lowerCamelCase__			:  int  =push
										lowerCamelCase__			:  List[str]  =extra_commit_description
										lowerCamelCase__			:  int  =override_model_class





							def    UpperCAmelCase__							(						self						:Optional[int]  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:Any ):





										"""simple docstring"""

										def _get_audio_input():
													lowerCamelCase__			:  int  =load_dataset('hf-internal-testing/librispeech_asr_dummy'  ,							'clean'  ,							split='validation' )
													lowerCamelCase__			:  Dict  =ds.sort('id' ).select(range(2 ) )[:2]['audio']
													lowerCamelCase__			:  List[str]  =[x['array'] for x in speech_samples]
													return raw_samples

										lowerCamelCase__			:  Union[str, Any]  =type(pt_model.config )
										if model_config_class in PROCESSOR_MAPPING:
													lowerCamelCase__			:  Dict  =AutoProcessor.from_pretrained(self._local_dir )
													if model_config_class in TOKENIZER_MAPPING and processor.tokenizer.pad_token is None:
																lowerCamelCase__			:  Dict  =processor.tokenizer.eos_token
										elif model_config_class in IMAGE_PROCESSOR_MAPPING:
													lowerCamelCase__			:  Tuple  =AutoImageProcessor.from_pretrained(self._local_dir )
										elif model_config_class in FEATURE_EXTRACTOR_MAPPING:
													lowerCamelCase__			:  List[Any]  =AutoFeatureExtractor.from_pretrained(self._local_dir )
										elif model_config_class in TOKENIZER_MAPPING:
													lowerCamelCase__			:  Optional[Any]  =AutoTokenizer.from_pretrained(self._local_dir )
													if processor.pad_token is None:
																lowerCamelCase__			:  Union[str, Any]  =processor.eos_token
										else:
													raise ValueError(f"""Unknown data processing type (model config type: {model_config_class})""" )

										lowerCamelCase__			:  Tuple  =set(inspect.signature(pt_model.forward ).parameters.keys() )
										lowerCamelCase__			:  Any  ={}
										if "input_ids" in model_forward_signature:
													processor_inputs.update(
													    {
													        'text': ['Hi there!', 'I am a batch with more than one row and different input lengths.'],
													        'padding': True,
													        'truncation': True,
													    } )
										if "pixel_values" in model_forward_signature:
													lowerCamelCase__			:  List[str]  =load_dataset('cifar10'  ,							'plain_text'  ,							split='test' )[:2]['img']
													processor_inputs.update({'images': sample_images} )
										if "input_features" in model_forward_signature:
													lowerCamelCase__			:  Optional[Any]  =inspect.signature(processor.feature_extractor ).parameters
													# Pad to the largest input length by default but take feature extractor default
													# padding value if it exists e.g. "max_length" and is not False or None
													if "padding" in feature_extractor_signature:
																lowerCamelCase__			:  str  =feature_extractor_signature['padding'].default
																if default_strategy is not False and default_strategy is not None:
																			lowerCamelCase__			:  Tuple  =default_strategy
																else:
																			lowerCamelCase__			:  List[str]  =True
													else:
																lowerCamelCase__			:  Optional[int]  =True
													processor_inputs.update({'audio': _get_audio_input(), 'padding': padding_strategy} )
										if "input_values" in model_forward_signature:  # Wav2Vec2 audio input
													processor_inputs.update({'audio': _get_audio_input(), 'padding': True} )
										lowerCamelCase__			:  str  =processor(**lowerCamelCase_  ,							return_tensors='pt' )
										lowerCamelCase__			:  Optional[int]  =processor(**lowerCamelCase_  ,							return_tensors='tf' )

										# Extra input requirements, in addition to the input modality
										if (
										    config.is_encoder_decoder
										    or (hasattr(lowerCamelCase_  ,							'encoder' ) and hasattr(lowerCamelCase_  ,							'decoder' ))
										    or "decoder_input_ids" in tf_dummy_inputs
										):
													lowerCamelCase__			:  Union[str, Any]  =np.asarray([[1], [1]]  ,							dtype=lowerCamelCase_ ) * (pt_model.config.decoder_start_token_id or 0)
													pt_input.update({'decoder_input_ids': torch.tensor(lowerCamelCase_ )} )
													tf_input.update({'decoder_input_ids': tf.convert_to_tensor(lowerCamelCase_ )} )

										return pt_input, tf_input





							def    UpperCAmelCase__							(						self						:List[Any] ):





										"""simple docstring"""

										if version.parse(huggingface_hub.__version__ ) < version.parse('0.9.0' ):
													raise ImportError(
													    'The huggingface_hub version must be >= 0.9.0 to use this command. Please update your huggingface_hub'
													    ' installation.' )
										else:
													from huggingface_hub import Repository, create_commit
													from huggingface_hub._commit_api import CommitOperationAdd

										# Fetch remote data
										lowerCamelCase__			:  Dict  =Repository(local_dir=self._local_dir  ,							clone_from=self._model_name )

										# Load config and get the appropriate architecture -- the latter is needed to convert the head's weights
										lowerCamelCase__			:  Union[str, Any]  =AutoConfig.from_pretrained(self._local_dir )
										lowerCamelCase__			:  Optional[int]  =config.architectures
										if self._override_model_class is not None:
													if self._override_model_class.startswith('TF' ):
																lowerCamelCase__			:  List[Any]  =[self._override_model_class[2:]]
													else:
																lowerCamelCase__			:  str  =[self._override_model_class]
													try:
																lowerCamelCase__			:  str  =getattr(import_module('transformers' )  ,							architectures[0] )
													except AttributeError:
																raise ValueError(f"""Model class {self._override_model_class} not found in transformers.""" )
													try:
																lowerCamelCase__			:  Tuple  =getattr(import_module('transformers' )  ,							'TF' + architectures[0] )
													except AttributeError:
																raise ValueError(f"""TF model class TF{self._override_model_class} not found in transformers.""" )
										elif architectures is None:  # No architecture defined -- use auto classes
													lowerCamelCase__			:  List[str]  =getattr(import_module('transformers' )  ,							'AutoModel' )
													lowerCamelCase__			:  Union[str, Any]  =getattr(import_module('transformers' )  ,							'TFAutoModel' )
													self._logger.warning('No detected architecture, using AutoModel/TFAutoModel' )
										else:  # Architecture defined -- use it
													if len(lowerCamelCase_ ) > 1:
																raise ValueError(f"""More than one architecture was found, aborting. (architectures = {architectures})""" )
													self._logger.warning(f"""Detected architecture: {architectures[0]}""" )
													lowerCamelCase__			:  str  =getattr(import_module('transformers' )  ,							architectures[0] )
													try:
																lowerCamelCase__			:  Tuple  =getattr(import_module('transformers' )  ,							'TF' + architectures[0] )
													except AttributeError:
																raise AttributeError(f"""The TensorFlow equivalent of {architectures[0]} doesn't exist in transformers.""" )

        # Check the TF dummy inputs to see what keys we need in the forward pass
										lowerCamelCase__			:  Any  =tf_class.from_config(lowerCamelCase_ )
										lowerCamelCase__			:  List[Any]  =tf_from_pt_model.dummy_inputs

										del tf_from_pt_model  # Try to keep only one model in memory at a time

										# Load the model and get some basic inputs
										lowerCamelCase__			:  List[str]  =pt_class.from_pretrained(self._local_dir )
										pt_model.eval()

										lowerCamelCase__ ,       lowerCamelCase__			:  Dict  =self.get_inputs(lowerCamelCase_  ,							lowerCamelCase_  ,							lowerCamelCase_ )

										with torch.no_grad():
													lowerCamelCase__			:  int  =pt_model(**lowerCamelCase_  ,							output_hidden_states=lowerCamelCase_ )
										del pt_model  # will no longer be used, and may have a large memory footprint

										lowerCamelCase__			:  Tuple  =tf_class.from_pretrained(self._local_dir  ,							from_pt=lowerCamelCase_ )
										lowerCamelCase__			:  int  =tf_from_pt_model(**lowerCamelCase_  ,							output_hidden_states=lowerCamelCase_  ,							training=lowerCamelCase_ )

										# Confirms that cross loading PT weights into TF worked.
										lowerCamelCase__			:  Dict  =self.find_pt_tf_differences(lowerCamelCase_  ,							lowerCamelCase_ )
										lowerCamelCase__			:  Optional[Any]  ={k: v for k, v in crossload_differences.items() if 'hidden' not in k}
										lowerCamelCase__			:  str  ={k: v for k, v in crossload_differences.items() if 'hidden' in k}
										if len(lowerCamelCase_ ) == 0 and architectures is not None:
													raise ValueError(
													    f"""Something went wrong -- the config file has architectures ({architectures}), but no model head"""
													    ' output was found. All outputs start with \'hidden\'' )
										lowerCamelCase__			:  Any  =max(output_differences.values() ) if output_differences else 0.0
										lowerCamelCase__			:  List[Any]  =max(hidden_differences.values() )
										if max_crossload_output_diff > self._max_error or max_crossload_hidden_diff > self._max_error:
													raise ValueError(
													    'The cross-loaded TensorFlow model has different outputs, something went wrong!\n'
													    + f"""\nList of maximum output differences above the threshold ({self._max_error}):\n"""
													    + '\n'.join([f"""{k}: {v:.3e}""" for k, v in output_differences.items() if v > self._max_error] )
													    + f"""\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n"""
													    + '\n'.join([f"""{k}: {v:.3e}""" for k, v in hidden_differences.items() if v > self._max_error] ) )

										# Save the weights in a TF format (if needed) and confirms that the results are still good
										lowerCamelCase__			:  Union[str, Any]  =os.path.join(self._local_dir  ,							lowerCamelCase_ )
										lowerCamelCase__			:  List[str]  =os.path.join(self._local_dir  ,							lowerCamelCase_ )
										if (not os.path.exists(lowerCamelCase_ ) and not os.path.exists(lowerCamelCase_ )) or self._new_weights:
													tf_from_pt_model.save_pretrained(self._local_dir )
										del tf_from_pt_model  # will no longer be used, and may have a large memory footprint

										lowerCamelCase__			:  Optional[int]  =tf_class.from_pretrained(self._local_dir )
										lowerCamelCase__			:  List[Any]  =tf_model(**lowerCamelCase_  ,							output_hidden_states=lowerCamelCase_ )

										lowerCamelCase__			:  Any  =self.find_pt_tf_differences(lowerCamelCase_  ,							lowerCamelCase_ )
										lowerCamelCase__			:  Tuple  ={k: v for k, v in conversion_differences.items() if 'hidden' not in k}
										lowerCamelCase__			:  Tuple  ={k: v for k, v in conversion_differences.items() if 'hidden' in k}
										if len(lowerCamelCase_ ) == 0 and architectures is not None:
													raise ValueError(
													    f"""Something went wrong -- the config file has architectures ({architectures}), but no model head"""
													    ' output was found. All outputs start with \'hidden\'' )
										lowerCamelCase__			:  Any  =max(output_differences.values() ) if output_differences else 0.0
										lowerCamelCase__			:  Any  =max(hidden_differences.values() )
										if max_conversion_output_diff > self._max_error or max_conversion_hidden_diff > self._max_error:
													raise ValueError(
													    'The converted TensorFlow model has different outputs, something went wrong!\n'
													    + f"""\nList of maximum output differences above the threshold ({self._max_error}):\n"""
													    + '\n'.join([f"""{k}: {v:.3e}""" for k, v in output_differences.items() if v > self._max_error] )
													    + f"""\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n"""
													    + '\n'.join([f"""{k}: {v:.3e}""" for k, v in hidden_differences.items() if v > self._max_error] ) )

										lowerCamelCase__			:  List[str]  ='Update TF weights' if self._new_weights else 'Add TF weights'
										if self._push:
													repo.git_add(auto_lfs_track=lowerCamelCase_ )
													repo.git_commit(lowerCamelCase_ )
													repo.git_push(blocking=lowerCamelCase_ )  # this prints a progress bar with the upload
													self._logger.warning(f"""TF weights pushed into {self._model_name}""" )
										elif not self._no_pr:
													self._logger.warning('Uploading the weights into a new PR...' )
													lowerCamelCase__			:  List[Any]  =(
													    'Model converted by the [`transformers`\' `pt_to_tf`'
													    ' CLI](https://github.com/huggingface/transformers/blob/main/src/transformers/commands/pt_to_tf.py). '
													    'All converted model outputs and hidden layers were validated against its PyTorch counterpart.\n\n'
													    f"""Maximum crossload output difference={max_crossload_output_diff:.3e}; """
													    f"""Maximum crossload hidden layer difference={max_crossload_hidden_diff:.3e};\n"""
													    f"""Maximum conversion output difference={max_conversion_output_diff:.3e}; """
													    f"""Maximum conversion hidden layer difference={max_conversion_hidden_diff:.3e};\n"""
													)
													if self._max_error > MAX_ERROR:
																commit_descrition += (
																    f"""\n\nCAUTION: The maximum admissible error was manually increased to {self._max_error}!"""
																)
													if self._extra_commit_description:
																commit_descrition += "\n\n" + self._extra_commit_description

													# sharded model -> adds all related files (index and .h5 shards)
													if os.path.exists(lowerCamelCase_ ):
																lowerCamelCase__			:  Dict  =[
																    CommitOperationAdd(path_in_repo=lowerCamelCase_  ,							path_or_fileobj=lowerCamelCase_ )
																]
																for shard_path in tf.io.gfile.glob(self._local_dir + '/tf_model-*.h5' ):
																			operations += [
																			    CommitOperationAdd(path_in_repo=os.path.basename(lowerCamelCase_ )  ,							path_or_fileobj=lowerCamelCase_ )
																			]
													else:
																lowerCamelCase__			:  Optional[Any]  =[CommitOperationAdd(path_in_repo=lowerCamelCase_  ,							path_or_fileobj=lowerCamelCase_ )]

													lowerCamelCase__			:  Tuple  =create_commit(
													    repo_id=self._model_name  ,							operations=lowerCamelCase_  ,							commit_message=lowerCamelCase_  ,							commit_description=lowerCamelCase_  ,							repo_type='model'  ,							create_pr=lowerCamelCase_  ,							).pr_url
													self._logger.warning(f"""PR open in {hub_pr_url}""" )