'''simple docstring'''




import glob
import os
from typing import Dict, List, Union

import torch

from diffusers.utils import is_safetensors_available


if is_safetensors_available():
		import safetensors.torch

from huggingface_hub import snapshot_download

from diffusers import DiffusionPipeline, __version__
from diffusers.schedulers.scheduling_utils import SCHEDULER_CONFIG_NAME
from diffusers.utils import CONFIG_NAME, DIFFUSERS_CACHE, ONNX_WEIGHTS_NAME, WEIGHTS_NAME

class 			lowerCamelCase_			(__UpperCAmelCase					):
						'''simple docstring'''

						def __init__( self		:       int ):
													self.register_to_config()
													super().__init__()




						def   _A			( self		:       Optional[int]		,      A		:       int		,      A		:       Dict ):



													if dicta == dicta:
																				return True
													else:
																				_UpperCAmelCase   ,						_UpperCAmelCase  :						str							   =					self._remove_meta_keys(lowerCamelCase__ )
																				_UpperCAmelCase   ,						_UpperCAmelCase  :						List[Any]							   =					self._remove_meta_keys(lowerCamelCase__ )
																				if configa == configa:
																											print(F"""Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}.""" )
																											return True
													return False




						def   _A			( self		:       str		,      A		:       Dict ):
													_UpperCAmelCase  :						str							   =					[]
													_UpperCAmelCase  :						Any							   =					config_dict.copy()
													for key in config_dict.keys():
																				if key.startswith("_" ):
																											temp_dict.pop(lowerCamelCase__ )
																											meta_keys.append(lowerCamelCase__ )
													return (temp_dict, meta_keys)




						@torch.no_grad()
						def   _A			( self		:       Union[str, Any]		,      A		:       List[str]		,      **A		:       Dict ):
													_UpperCAmelCase  :						Any							   =					kwargs.pop("cache_dir"		,      lowerCamelCase__ )
													_UpperCAmelCase  :						Dict							   =					kwargs.pop("resume_download"		,      lowerCamelCase__ )
													_UpperCAmelCase  :						List[str]							   =					kwargs.pop("force_download"		,      lowerCamelCase__ )
													_UpperCAmelCase  :						List[str]							   =					kwargs.pop("proxies"		,      lowerCamelCase__ )
													_UpperCAmelCase  :						int							   =					kwargs.pop("local_files_only"		,      lowerCamelCase__ )
													_UpperCAmelCase  :						Dict							   =					kwargs.pop("use_auth_token"		,      lowerCamelCase__ )
													_UpperCAmelCase  :						Tuple							   =					kwargs.pop("revision"		,      lowerCamelCase__ )
													_UpperCAmelCase  :						Union[str, Any]							   =					kwargs.pop("torch_dtype"		,      lowerCamelCase__ )
													_UpperCAmelCase  :						str							   =					kwargs.pop("device_map"		,      lowerCamelCase__ )

													_UpperCAmelCase  :						Dict							   =					kwargs.pop("alpha"		,      0.5 )
													_UpperCAmelCase  :						Optional[int]							   =					kwargs.pop("interp"		,      lowerCamelCase__ )

													print("Received list"		,      lowerCamelCase__ )
													print(F"""Combining with alpha={alpha}, interpolation mode={interp}""" )

													_UpperCAmelCase  :						List[str]							   =					len(lowerCamelCase__ )
													# Ignore result from model_index_json comparision of the two checkpoints
													_UpperCAmelCase  :						List[Any]							   =					kwargs.pop("force"		,      lowerCamelCase__ )

													# If less than 2 checkpoints, nothing to merge. If more than 3, not supported for now.
													if checkpoint_count > 3 or checkpoint_count < 2:
																				raise ValueError(
																				    "Received incorrect number of checkpoints to merge. Ensure that either 2 or 3 checkpoints are being"
																				    " passed." )

													print("Received the right number of checkpoints" )
													# chkpt0, chkpt1 = pretrained_model_name_or_path_list[0:2]
													# chkpt2 = pretrained_model_name_or_path_list[2] if checkpoint_count == 3 else None

													# Validate that the checkpoints can be merged
													# Step 1: Load the model config and compare the checkpoints. We'll compare the model_index.json first while ignoring the keys starting with '_'
													_UpperCAmelCase  :						List[str]							   =					[]
													for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
																				_UpperCAmelCase  :						Optional[Any]							   =					DiffusionPipeline.load_config(
																				    lowerCamelCase__		,      cache_dir=lowerCamelCase__		,      resume_download=lowerCamelCase__		,      force_download=lowerCamelCase__		,      proxies=lowerCamelCase__		,      local_files_only=lowerCamelCase__		,      use_auth_token=lowerCamelCase__		,      revision=lowerCamelCase__		,      )
																				config_dicts.append(lowerCamelCase__ )

													_UpperCAmelCase  :						Optional[Any]							   =					True
													for idx in range(1		,      len(lowerCamelCase__ ) ):
																				comparison_result &= self._compare_model_configs(config_dicts[idx - 1]		,      config_dicts[idx] )
																				if not force and comparison_result is False:
																											raise ValueError("Incompatible checkpoints. Please check model_index.json for the models." )
																											print(config_dicts[0]		,      config_dicts[1] )
													print("Compatible model_index.json files found" )
													# Step 2: Basic Validation has succeeded. Let's download the models and save them into our local files.
													_UpperCAmelCase  :						Union[str, Any]							   =					[]
													for pretrained_model_name_or_path, config_dict in zip(lowerCamelCase__		,      lowerCamelCase__ ):
																				_UpperCAmelCase  :						Optional[Any]							   =					[k for k in config_dict.keys() if not k.startswith("_" )]
																				_UpperCAmelCase  :						List[str]							   =					[os.path.join(lowerCamelCase__		,      "*" ) for k in folder_names]
																				allow_patterns += [
																				    WEIGHTS_NAME,
																				    SCHEDULER_CONFIG_NAME,
																				    CONFIG_NAME,
																				    ONNX_WEIGHTS_NAME,
																				    DiffusionPipeline.config_name,
																				]
																				_UpperCAmelCase  :						Dict							   =					config_dict.get("_class_name" )
																				_UpperCAmelCase  :						Union[str, Any]							   =					{"diffusers": __version__, "pipeline_class": requested_pipeline_class}

																				_UpperCAmelCase  :						Any							   =					(
																				    pretrained_model_name_or_path
																				    if os.path.isdir(lowerCamelCase__ )
																				    else snapshot_download(
																				        lowerCamelCase__		,      cache_dir=lowerCamelCase__		,      resume_download=lowerCamelCase__		,      proxies=lowerCamelCase__		,      local_files_only=lowerCamelCase__		,      use_auth_token=lowerCamelCase__		,      revision=lowerCamelCase__		,      allow_patterns=lowerCamelCase__		,      user_agent=lowerCamelCase__		,      )
																				)
																				print("Cached Folder"		,      lowerCamelCase__ )
																				cached_folders.append(lowerCamelCase__ )

													# Step 3:-
													# Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
													_UpperCAmelCase  :						Optional[Any]							   =					DiffusionPipeline.from_pretrained(
													    cached_folders[0]		,      torch_dtype=lowerCamelCase__		,      device_map=lowerCamelCase__ )
													final_pipe.to(self.device )

													_UpperCAmelCase  :						str							   =					None
													if len(lowerCamelCase__ ) > 2:
																				_UpperCAmelCase  :						Optional[Any]							   =					os.path.join(cached_folders[2] )

													if interp == "sigmoid":
																				_UpperCAmelCase  :						Union[str, Any]							   =					CheckpointMergerPipeline.sigmoid
													elif interp == "inv_sigmoid":
																				_UpperCAmelCase  :						int							   =					CheckpointMergerPipeline.inv_sigmoid
													elif interp == "add_diff":
																				_UpperCAmelCase  :						Tuple							   =					CheckpointMergerPipeline.add_difference
													else:
																				_UpperCAmelCase  :						List[Any]							   =					CheckpointMergerPipeline.weighted_sum

													# Find each module's state dict.
													for attr in final_pipe.config.keys():
																				if not attr.startswith("_" ):
																											_UpperCAmelCase  :						Dict							   =					os.path.join(cached_folders[1]		,      lowerCamelCase__ )
																											if os.path.exists(lowerCamelCase__ ):
																																		_UpperCAmelCase  :						Any							   =					[
																																		    *glob.glob(os.path.join(lowerCamelCase__		,      "*.safetensors" ) ),
																																		    *glob.glob(os.path.join(lowerCamelCase__		,      "*.bin" ) ),
																																		]
																																		_UpperCAmelCase  :						Dict							   =					files[0] if len(lowerCamelCase__ ) > 0 else None
																											if len(lowerCamelCase__ ) < 3:
																																		_UpperCAmelCase  :						int							   =					None
																											else:
																																		_UpperCAmelCase  :						List[str]							   =					os.path.join(cached_folders[2]		,      lowerCamelCase__ )
																																		if os.path.exists(lowerCamelCase__ ):
																																									_UpperCAmelCase  :						Any							   =					[
																																									    *glob.glob(os.path.join(lowerCamelCase__		,      "*.safetensors" ) ),
																																									    *glob.glob(os.path.join(lowerCamelCase__		,      "*.bin" ) ),
																																									]
																																									_UpperCAmelCase  :						List[Any]							   =					files[0] if len(lowerCamelCase__ ) > 0 else None
                # For an attr if both checkpoint_path_1 and 2 are None, ignore.
                # If atleast one is present, deal with it according to interp method, of course only if the state_dict keys match.
																											if checkpoint_path_a is None and checkpoint_path_a is None:
																																		print(F"""Skipping {attr}: not present in 2nd or 3d model""" )
																																		continue
																											try:
																																		_UpperCAmelCase  :						int							   =					getattr(lowerCamelCase__		,      lowerCamelCase__ )
																																		if isinstance(lowerCamelCase__		,      lowerCamelCase__ ):  # ignore requires_safety_checker boolean
																																									continue
																																		_UpperCAmelCase  :						Optional[int]							   =					getattr(lowerCamelCase__		,      "state_dict" )
																																		_UpperCAmelCase  :						Tuple							   =					theta_a()

																																		_UpperCAmelCase  :						List[str]							   =					getattr(lowerCamelCase__		,      "load_state_dict" )
																																		_UpperCAmelCase  :						Optional[int]							   =					(
																																		    safetensors.torch.load_file(lowerCamelCase__ )
																																		    if (is_safetensors_available() and checkpoint_path_a.endswith(".safetensors" ))
																																		    else torch.load(lowerCamelCase__		,      map_location="cpu" )
																																		)
																																		_UpperCAmelCase  :						str							   =					None
																																		if checkpoint_path_a:
																																									_UpperCAmelCase  :						Any							   =					(
																																									    safetensors.torch.load_file(lowerCamelCase__ )
																																									    if (is_safetensors_available() and checkpoint_path_a.endswith(".safetensors" ))
																																									    else torch.load(lowerCamelCase__		,      map_location="cpu" )
																																									)

																																		if not theta_a.keys() == theta_a.keys():
																																									print(F"""Skipping {attr}: key mismatch""" )
																																									continue
																																		if theta_a and not theta_a.keys() == theta_a.keys():
																																									print(F"""Skipping {attr}:y mismatch""" )
																											except Exception as e:
																																		print(F"""Skipping {attr} do to an unexpected error: {str(lowerCamelCase__ )}""" )
																																		continue
																											print(F"""MERGING {attr}""" )

																											for key in theta_a.keys():
																																		if theta_a:
																																									_UpperCAmelCase  :						str							   =					theta_func(theta_a[key]		,      theta_a[key]		,      theta_a[key]		,      lowerCamelCase__ )
																																		else:
																																									_UpperCAmelCase  :						Tuple							   =					theta_func(theta_a[key]		,      theta_a[key]		,      lowerCamelCase__		,      lowerCamelCase__ )

																											del theta_a
																											del theta_a
																											update_theta_a(lowerCamelCase__ )

																											del theta_a
													return final_pipe




						@staticmethod
						def   _A			( A		:       str		,      A		:       Optional[int]		,      A		:       List[str]		,      A		:       str ):
													return ((1 - alpha) * thetaa) + (alpha * thetaa)




						@staticmethod
						def   _A			( A		:       int		,      A		:       List[str]		,      A		:       Optional[Any]		,      A		:       int ):
													_UpperCAmelCase  :						Optional[Any]							   =					alpha * alpha * (3 - (2 * alpha))
													return thetaa + ((thetaa - thetaa) * alpha)




						@staticmethod
						def   _A			( A		:       int		,      A		:       Dict		,      A		:       Optional[int]		,      A		:       Optional[int] ):
													import math

													_UpperCAmelCase  :						List[str]							   =					0.5 - math.sin(math.asin(1.0 - 2.0 * alpha ) / 3.0 )
													return thetaa + ((thetaa - thetaa) * alpha)





						@staticmethod
						def   _A			( A		:       str		,      A		:       List[Any]		,      A		:       Union[str, Any]		,      A		:       List[Any] ):
													return thetaa + (thetaa - thetaa) * (1.0 - alpha)


'''simple docstring'''




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 			lowerCamelCase_			:
      '''simple docstring'''

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




      def   _A			( self		:       Any ):
             _UpperCAmelCase  :						Union[str, Any]							   =					ids_tensor([self.batch_size, self.seq_length]		,      self.vocab_size )

             _UpperCAmelCase  :						int							   =					None
             if self.use_input_mask:
                    _UpperCAmelCase  :						List[str]							   =					random_attention_mask([self.batch_size, self.seq_length] )

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

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

             _UpperCAmelCase  :						Any							   =					self.get_config()

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




      def   _A			( self		:       List[str] ):
             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=A		,      initializer_range=self.initializer_range		,      )




      def   _A			( self		:       Union[str, Any] ):
             (
                 (
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						
             )  :						Dict							   =					self.prepare_config_and_inputs()

             _UpperCAmelCase  :						int							   =					True
             _UpperCAmelCase  :						Any							   =					floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
             _UpperCAmelCase  :						List[Any]							   =					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   _A			( self		:       Union[str, Any]		,      A		:       Dict		,      A		:       int		,      A		:       Any		,      A		:       Tuple		,      A		:       Union[str, Any]		,      A		:       int		,      A		:       str		,      A		:       Union[str, Any]		,      ):
             _UpperCAmelCase  :						Any							   =					ElectraModel(config=A )
             model.to(A )
             model.eval()
             _UpperCAmelCase  :						Optional[int]							   =					model(A		,      attention_mask=A		,      token_type_ids=A )
             _UpperCAmelCase  :						Tuple							   =					model(A		,      token_type_ids=A )
             _UpperCAmelCase  :						List[str]							   =					model(A )
             self.parent.assertEqual(result.last_hidden_state.shape		,      (self.batch_size, self.seq_length, self.hidden_size) )




      def   _A			( self		:       List[Any]		,      A		:       Any		,      A		:       Optional[int]		,      A		:       List[Any]		,      A		:       Dict		,      A		:       List[Any]		,      A		:       Optional[int]		,      A		:       List[str]		,      A		:       Dict		,      A		:       str		,      ):
             _UpperCAmelCase  :						Optional[Any]							   =					True
             _UpperCAmelCase  :						List[str]							   =					ElectraModel(A )
             model.to(A )
             model.eval()
             _UpperCAmelCase  :						int							   =					model(
                 A		,      attention_mask=A		,      token_type_ids=A		,      encoder_hidden_states=A		,      encoder_attention_mask=A		,      )
             _UpperCAmelCase  :						Tuple							   =					model(
                 A		,      attention_mask=A		,      token_type_ids=A		,      encoder_hidden_states=A		,      )
             _UpperCAmelCase  :						Union[str, Any]							   =					model(A		,      attention_mask=A		,      token_type_ids=A )
             self.parent.assertEqual(result.last_hidden_state.shape		,      (self.batch_size, self.seq_length, self.hidden_size) )




      def   _A			( self		:       Optional[int]		,      A		:       int		,      A		:       Optional[Any]		,      A		:       int		,      A		:       Tuple		,      A		:       List[str]		,      A		:       Optional[Any]		,      A		:       str		,      A		:       Dict		,      ):
             _UpperCAmelCase  :						Optional[Any]							   =					ElectraForMaskedLM(config=A )
             model.to(A )
             model.eval()
             _UpperCAmelCase  :						int							   =					model(A		,      attention_mask=A		,      token_type_ids=A		,      labels=A )
             self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.seq_length, self.vocab_size) )




      def   _A			( self		:       Optional[Any]		,      A		:       Optional[int]		,      A		:       Optional[int]		,      A		:       Any		,      A		:       str		,      A		:       Optional[int]		,      A		:       Any		,      A		:       str		,      A		:       int		,      A		:       Dict		,      ):
             _UpperCAmelCase  :						Tuple							   =					ElectraForCausalLM(config=A )
             model.to(A )
             model.eval()
             _UpperCAmelCase  :						List[Any]							   =					model(A		,      attention_mask=A		,      token_type_ids=A		,      labels=A )
             self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.seq_length, self.vocab_size) )




      def   _A			( self		:       List[str]		,      A		:       Tuple		,      A		:       Dict		,      A		:       Tuple		,      A		:       List[str]		,      A		:       List[Any]		,      A		:       Optional[Any]		,      A		:       str		,      A		:       Dict		,      ):
             _UpperCAmelCase  :						Any							   =					self.num_labels
             _UpperCAmelCase  :						Tuple							   =					ElectraForTokenClassification(config=A )
             model.to(A )
             model.eval()
             _UpperCAmelCase  :						Union[str, Any]							   =					model(A		,      attention_mask=A		,      token_type_ids=A		,      labels=A )
             self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.seq_length, self.num_labels) )




      def   _A			( self		:       Union[str, Any]		,      A		:       Optional[Any]		,      A		:       Optional[int]		,      A		:       Union[str, Any]		,      A		:       str		,      A		:       Union[str, Any]		,      A		:       Tuple		,      A		:       Optional[int]		,      A		:       Optional[int]		,      ):
             _UpperCAmelCase  :						Union[str, Any]							   =					self.num_labels
             _UpperCAmelCase  :						int							   =					ElectraForPreTraining(config=A )
             model.to(A )
             model.eval()
             _UpperCAmelCase  :						Dict							   =					model(A		,      attention_mask=A		,      token_type_ids=A		,      labels=A )
             self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.seq_length) )




      def   _A			( self		:       Union[str, Any]		,      A		:       List[Any]		,      A		:       int		,      A		:       int		,      A		:       Optional[int]		,      A		:       Optional[Any]		,      A		:       Dict		,      A		:       str		,      A		:       Any		,      ):
             _UpperCAmelCase  :						Union[str, Any]							   =					self.num_labels
             _UpperCAmelCase  :						List[str]							   =					ElectraForSequenceClassification(A )
             model.to(A )
             model.eval()
             _UpperCAmelCase  :						str							   =					model(A		,      attention_mask=A		,      token_type_ids=A		,      labels=A )
             self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.num_labels) )




      def   _A			( self		:       List[str]		,      A		:       Optional[Any]		,      A		:       Optional[int]		,      A		:       Tuple		,      A		:       Optional[Any]		,      A		:       int		,      A		:       List[str]		,      A		:       Tuple		,      A		:       Optional[int]		,      ):
             _UpperCAmelCase  :						List[str]							   =					ElectraForQuestionAnswering(config=A )
             model.to(A )
             model.eval()
             _UpperCAmelCase  :						Any							   =					model(
                 A		,      attention_mask=A		,      token_type_ids=A		,      start_positions=A		,      end_positions=A		,      )
             self.parent.assertEqual(result.start_logits.shape		,      (self.batch_size, self.seq_length) )
             self.parent.assertEqual(result.end_logits.shape		,      (self.batch_size, self.seq_length) )




      def   _A			( self		:       int		,      A		:       Optional[Any]		,      A		:       Optional[Any]		,      A		:       Tuple		,      A		:       Dict		,      A		:       Optional[Any]		,      A		:       Union[str, Any]		,      A		:       Optional[Any]		,      A		:       str		,      ):
             _UpperCAmelCase  :						Tuple							   =					self.num_choices
             _UpperCAmelCase  :						int							   =					ElectraForMultipleChoice(config=A )
             model.to(A )
             model.eval()
             _UpperCAmelCase  :						str							   =					input_ids.unsqueeze(1 ).expand(-1		,      self.num_choices		,      -1 ).contiguous()
             _UpperCAmelCase  :						Dict							   =					token_type_ids.unsqueeze(1 ).expand(-1		,      self.num_choices		,      -1 ).contiguous()
             _UpperCAmelCase  :						Union[str, Any]							   =					input_mask.unsqueeze(1 ).expand(-1		,      self.num_choices		,      -1 ).contiguous()
             _UpperCAmelCase  :						Union[str, Any]							   =					model(
                 A		,      attention_mask=A		,      token_type_ids=A		,      labels=A		,      )
             self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.num_choices) )





      def   _A			( self		:       Any ):
             _UpperCAmelCase  :						List[Any]							   =					self.prepare_config_and_inputs()
             (
                 (
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						(
                 _UpperCAmelCase
             )   ,						
             )  :						Tuple							   =					config_and_inputs
             _UpperCAmelCase  :						List[Any]							   =					{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
             return config, inputs_dict

@require_torch
class 			lowerCamelCase_			(snake_case__							,				snake_case__							,				unittest.TestCase					):
      '''simple docstring'''

      __UpperCamelCase:						Tuple      			=		(
          (
              ElectraModel,
              ElectraForPreTraining,
              ElectraForMaskedLM,
              ElectraForCausalLM,
              ElectraForMultipleChoice,
              ElectraForTokenClassification,
              ElectraForSequenceClassification,
              ElectraForQuestionAnswering,
          )
          if is_torch_available()
          else ()
      )
      __UpperCamelCase:						Optional[Any]      			=		(
          {
              "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 {}
      )
      __UpperCamelCase:						str      			=		True




      def   _A			( self		:       Optional[Any]		,      A		:       Tuple		,      A		:       Optional[Any]		,      A		:       List[Any]=False ):
             _UpperCAmelCase  :						int							   =					super()._prepare_for_class(A		,      A		,      return_labels=A )

             if return_labels:
                    if model_class in get_values(A ):
                           _UpperCAmelCase  :						List[str]							   =					torch.zeros(
                               (self.model_tester.batch_size, self.model_tester.seq_length)		,      dtype=torch.long		,      device=A )
             return inputs_dict




      def   _A			( self		:       Optional[int] ):
             _UpperCAmelCase  :						Any							   =					ElectraModelTester(self )
             _UpperCAmelCase  :						Tuple							   =					ConfigTester(self		,      config_class=A		,      hidden_size=37 )




      def   _A			( self		:       Tuple ):
             self.config_tester.run_common_tests()




      def   _A			( self		:       Dict ):
             _UpperCAmelCase  :						Dict							   =					self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_model(*A )




      def   _A			( self		:       int ):
             _UpperCAmelCase  :						List[Any]							   =					self.model_tester.prepare_config_and_inputs_for_decoder()
             self.model_tester.create_and_check_electra_model_as_decoder(*A )




      def   _A			( self		:       Union[str, Any] ):
             _UpperCAmelCase  :						Optional[Any]							   =					self.model_tester.prepare_config_and_inputs()
             for type in ["absolute", "relative_key", "relative_key_query"]:
                    _UpperCAmelCase  :						Optional[int]							   =					type
                    self.model_tester.create_and_check_electra_model(*A )




      def   _A			( self		:       Optional[Any] ):
             _UpperCAmelCase  :						Optional[Any]							   =					self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_for_masked_lm(*A )




      def   _A			( self		:       Any ):
             _UpperCAmelCase  :						Optional[Any]							   =					self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_for_token_classification(*A )




      def   _A			( self		:       str ):
             _UpperCAmelCase  :						int							   =					self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_for_pretraining(*A )




      def   _A			( self		:       Tuple ):
             _UpperCAmelCase  :						List[str]							   =					self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_for_sequence_classification(*A )




      def   _A			( self		:       Dict ):
             _UpperCAmelCase  :						List[Any]							   =					self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_for_question_answering(*A )




      def   _A			( self		:       Dict ):
             _UpperCAmelCase  :						Optional[int]							   =					self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_for_multiple_choice(*A )




      @slow
      def   _A			( self		:       Union[str, Any] ):
             for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    _UpperCAmelCase  :						List[Any]							   =					ElectraModel.from_pretrained(A )
                    self.assertIsNotNone(A )





      def   _A			( self		:       List[Any] ):
             _UpperCAmelCase  :						Union[str, Any]							   =					self.model_tester.prepare_config_and_inputs_for_decoder()
             self.model_tester.create_and_check_electra_for_causal_lm(*A )

@require_torch
class 			lowerCamelCase_			(unittest.TestCase					):
      '''simple docstring'''

      @slow
      def   _A			( self		:       List[Any] ):
             _UpperCAmelCase  :						List[Any]							   =					ElectraModel.from_pretrained("google/electra-small-discriminator" )
             _UpperCAmelCase  :						List[Any]							   =					torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]] )
             _UpperCAmelCase  :						List[str]							   =					torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
             _UpperCAmelCase  :						str							   =					model(A		,      attention_mask=A )[0]
             _UpperCAmelCase  :						Union[str, Any]							   =					torch.Size((1, 11, 256) )
             self.assertEqual(output.shape		,      A )
             _UpperCAmelCase  :						Optional[Any]							   =					torch.tensor(
                 [[[0.4_471, 0.6_821, -0.3_265], [0.4_627, 0.5_255, -0.3_668], [0.4_532, 0.3_313, -0.4_344]]] )

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

