


'''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  lowercase_					:


    def __init__(					self  , a  , a=13  , a=7  , a=True  , a=True  , a=True  , a=True  , a=99  , a=32  , a=5  , a=4  , a=37  , a="gelu"  , a=0.1  , a=0.1  , a=5_12  , a=16  , a=2  , a=0.02  , a=3  , a=4  , a=None  , ):
          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__  =    scope


    def        __a							(					self   ):
          UpperCamelCase__  =    ids_tensor([self.batch_size, self.seq_length]  , self.vocab_size   )

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

          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__  =    ids_tensor([self.batch_size, self.seq_length]  , 1   )

          UpperCamelCase__  =    self.get_config()

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


    def        __a							(					self   ):
          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   ):
          (
              (
              UpperCamelCase__     
          ) ,     (
              UpperCamelCase__     
          ) ,     (
              UpperCamelCase__     
          ) ,     (
              UpperCamelCase__     
          ) ,     (
              UpperCamelCase__     
          ) ,     (
              UpperCamelCase__     
          ) ,     (
              UpperCamelCase__     
          ) ,     (
              UpperCamelCase__     
          ) ,          
          )  =    self.prepare_config_and_inputs()

          UpperCamelCase__  =    True
          UpperCamelCase__  =    floats_tensor([self.batch_size, self.seq_length, self.hidden_size]   )
          UpperCamelCase__  =    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  , a  , a  , a  , a  , a  , a  , a  , a  , ):
          UpperCamelCase__  =    ElectraModel(config=a   )
          model.to(a   )
          model.eval()
          UpperCamelCase__  =    model(a  , attention_mask=a  , token_type_ids=a   )
          UpperCamelCase__  =    model(a  , token_type_ids=a   )
          UpperCamelCase__  =    model(a   )
          self.parent.assertEqual(result.last_hidden_state.shape  , (self.batch_size, self.seq_length, self.hidden_size)   )


    def        __a							(					self  , a  , a  , a  , a  , a  , a  , a  , a  , a  , ):
          UpperCamelCase__  =    True
          UpperCamelCase__  =    ElectraModel(a   )
          model.to(a   )
          model.eval()
          UpperCamelCase__  =    model(
              a  , attention_mask=a  , token_type_ids=a  , encoder_hidden_states=a  , encoder_attention_mask=a  , )
          UpperCamelCase__  =    model(
              a  , attention_mask=a  , token_type_ids=a  , encoder_hidden_states=a  , )
          UpperCamelCase__  =    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  , a  , a  , a  , a  , a  , a  , a  , a  , ):
          UpperCamelCase__  =    ElectraForMaskedLM(config=a   )
          model.to(a   )
          model.eval()
          UpperCamelCase__  =    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  , a  , a  , a  , a  , a  , a  , a  , a  , a  , ):
          UpperCamelCase__  =    ElectraForCausalLM(config=a   )
          model.to(a   )
          model.eval()
          UpperCamelCase__  =    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  , a  , a  , a  , a  , a  , a  , a  , a  , ):
          UpperCamelCase__  =    self.num_labels
          UpperCamelCase__  =    ElectraForTokenClassification(config=a   )
          model.to(a   )
          model.eval()
          UpperCamelCase__  =    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  , a  , a  , a  , a  , a  , a  , a  , a  , ):
          UpperCamelCase__  =    self.num_labels
          UpperCamelCase__  =    ElectraForPreTraining(config=a   )
          model.to(a   )
          model.eval()
          UpperCamelCase__  =    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  , a  , a  , a  , a  , a  , a  , a  , a  , ):
          UpperCamelCase__  =    self.num_labels
          UpperCamelCase__  =    ElectraForSequenceClassification(a   )
          model.to(a   )
          model.eval()
          UpperCamelCase__  =    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  , a  , a  , a  , a  , a  , a  , a  , a  , ):
          UpperCamelCase__  =    ElectraForQuestionAnswering(config=a   )
          model.to(a   )
          model.eval()
          UpperCamelCase__  =    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  , a  , a  , a  , a  , a  , a  , a  , a  , ):
          UpperCamelCase__  =    self.num_choices
          UpperCamelCase__  =    ElectraForMultipleChoice(config=a   )
          model.to(a   )
          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(
              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   ):
          UpperCamelCase__  =    self.prepare_config_and_inputs()
          (
              (
              UpperCamelCase__     
          ) ,     (
              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  lowercase_					(   a__  ,						a__  ,						unittest.TestCase       ):
    __UpperCAmelCase             =     (
        (
            ElectraModel,
            ElectraForPreTraining,
            ElectraForMaskedLM,
            ElectraForCausalLM,
            ElectraForMultipleChoice,
            ElectraForTokenClassification,
            ElectraForSequenceClassification,
            ElectraForQuestionAnswering,
        )
        if is_torch_available()
        else ()
    )
    __UpperCAmelCase             =     (
        {
            '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             =     True


    def        __a							(					self  , a  , a  , a=False   ):
          UpperCamelCase__  =    super()._prepare_for_class(a  , a  , return_labels=a   )

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


    def        __a							(					self   ):
          UpperCamelCase__  =    ElectraModelTester(self   )
          UpperCamelCase__  =    ConfigTester(self  , config_class=a  , hidden_size=37   )


    def        __a							(					self   ):
          self.config_tester.run_common_tests()


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_model(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs_for_decoder()
          self.model_tester.create_and_check_electra_model_as_decoder(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          for type in ["absolute", "relative_key", "relative_key_query"]:
                UpperCamelCase__  =    type
                self.model_tester.create_and_check_electra_model(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_for_masked_lm(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_for_token_classification(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_for_pretraining(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_for_sequence_classification(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_for_question_answering(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_for_multiple_choice(*a   )


    @slow
    def        __a							(					self   ):
          for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                UpperCamelCase__  =    ElectraModel.from_pretrained(a   )
                self.assertIsNotNone(a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs_for_decoder()
          self.model_tester.create_and_check_electra_for_causal_lm(*a   )

@require_torch
class  lowercase_					(   unittest.TestCase       ):


    @slow
    def        __a							(					self   ):
          UpperCamelCase__  =    ElectraModel.from_pretrained("google/electra-small-discriminator"   )
          UpperCamelCase__  =    torch.tensor([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]]   )
          UpperCamelCase__  =    torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]   )
          UpperCamelCase__  =    model(a  , attention_mask=a   )[0]
          UpperCamelCase__  =    torch.Size((1, 11, 2_56)   )
          self.assertEqual(output.shape  , a   )
          UpperCamelCase__  =    torch.tensor(
              [[[0.4471, 0.6821, -0.3265], [0.4627, 0.5255, -0.3668], [0.4532, 0.3313, -0.4344]]]   )

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





'''simple docstring'''







a__  : str				=	[
    ['ab-e1', 'ac-e3', 'ad-e5', 'bc-e4', 'bd-e2', 'be-e6', 'bh-e12', 'cd-e2', 'ce-e4',
     'de-e1', 'df-e8', 'dg-e5', 'dh-e10', 'ef-e3', 'eg-e2', 'fg-e6', 'gh-e6', 'hi-e3'],
    ['ab-e1', 'ac-e3', 'ad-e5', 'bc-e4', 'bd-e2', 'be-e6', 'cd-e2', 'de-e1', 'df-e8',
     'ef-e3', 'eg-e2', 'fg-e6'],
    ['ab-e1', 'ac-e3', 'bc-e4', 'bd-e2', 'de-e1', 'df-e8', 'dg-e5', 'ef-e3', 'eg-e2',
     'eh-e12', 'fg-e6', 'fh-e10', 'gh-e6'],
    ['ab-e1', 'ac-e3', 'bc-e4', 'bd-e2', 'bh-e12', 'cd-e2', 'df-e8', 'dh-e10'],
    ['ab-e1', 'ac-e3', 'ad-e5', 'bc-e4', 'bd-e2', 'cd-e2', 'ce-e4', 'de-e1', 'df-e8',
     'dg-e5', 'ef-e3', 'eg-e2', 'fg-e6']
]







def _UpperCamelCase	(					__A   )							->		Tuple:


      '''simple docstring'''



      UpperCamelCase__  =    set()
      for row in edge_array:
            for item in row:
                  distinct_edge.add(item[0]   )
      return list(__A   )







def _UpperCamelCase	(					__A				,      __A   )							->		int:


      '''simple docstring'''



      UpperCamelCase__  =    ["0"] * len(__A   )
      for i, row in enumerate(__A   ):
            for item in row:
                  if distinct_edge in item[0]:
                        UpperCamelCase__  =    "1"
                        break
      return "".join(__A   )







def _UpperCamelCase	(					__A   )							->		Union[str, Any]:


      '''simple docstring'''



      UpperCamelCase__  =    get_distinct_edge(__A   )
      UpperCamelCase__  =    {}

      for item in distinct_edge:
            UpperCamelCase__  =    get_bitcode(__A				,      __A   )
            # print('bit',bit)
            # bt=''.join(bit)
            UpperCamelCase__  =    bit.count("1"   )
            UpperCamelCase__  =    [s, bit]
      # Store [Distinct edge, WT(Bitcode), Bitcode] in descending order
      UpperCamelCase__  =    [
          [k, v[0], v[1]]
          for k, v in sorted(frequency_table.items()				,      key=lambda __A   : v[1][0]				,      reverse=__A   )
      ]
      return sorted_frequency_table







def _UpperCamelCase	(					__A   )							->		Union[str, Any]:


      '''simple docstring'''



      UpperCamelCase__  =    {}
      for _, item in enumerate(__A   ):
            nodes.setdefault(item[2]				,      []   ).append(item[0]   )
      return nodes







def _UpperCamelCase	(					__A   )							->		Tuple:


      '''simple docstring'''



      UpperCamelCase__  =    {}
      for key, value in nodes.items():
            UpperCamelCase__  =    value
      return cluster







def _UpperCamelCase	(					__A   )							->		str:


      '''simple docstring'''



      return [i * 100 / len(__A   ) for i in cluster]







def _UpperCamelCase	(					)							->		None:


      '''simple docstring'''



      print("\nNodes\n"   )
      for key, value in nodes.items():
            print(__A				,      __A   )
      print("\nSupport\n"   )
      print(__A   )
      print("\n Cluster \n"   )
      for key, value in sorted(cluster.items()				,      reverse=__A   ):
            print(__A				,      __A   )
      print("\n Graph\n"   )
      for key, value in graph.items():
            print(__A				,      __A   )
      print("\n Edge List of Frequent subgraphs \n"   )
      for edge_list in freq_subgraph_edge_list:
            print(__A   )







def _UpperCamelCase	(					__A				,      __A				,      __A				,      __A   )							->		Optional[int]:


      '''simple docstring'''



      for i in cluster[ca]:
            UpperCamelCase__  =    0
            UpperCamelCase__  =    ca + 1
            while ca < max(cluster.keys()   ):
                  for j in cluster[ca]:
                        if int(__A				,      2   ) & int(__A				,      2   ) == int(__A				,      2   ):
                              if tuple(nodes[i]   ) in graph:
                                    graph[tuple(nodes[i]   )].append(nodes[j]   )
                              else:
                                    UpperCamelCase__  =    [nodes[j]]
                              count += 1
                  if count == 0:
                        UpperCamelCase__  =    ca + 1
                  else:
                        break







def _UpperCamelCase	(					__A				,      __A   )							->		List[str]:


      '''simple docstring'''



      UpperCamelCase__  =    cluster[max(cluster.keys()   )]
      UpperCamelCase__  =    "Header"
      UpperCamelCase__  =    {}
      for i in x:
            if (["Header"],) in graph:
                  graph[(["Header"],)].append(x[i]   )
            else:
                  UpperCamelCase__  =    [x[i]]
      for i in x:
            UpperCamelCase__  =    [["Header"]]
      UpperCamelCase__  =    1
      while i < max(__A   ) - 1:
            create_edge(__A				,      __A				,      __A				,      __A   )
            UpperCamelCase__  =    i + 1
      return graph







def _UpperCamelCase	(					__A				,      __A				,      __A				,      __A=None   )							->		str:


      '''simple docstring'''



      UpperCamelCase__  =    (path or []) + [start]
      if start == end:
            paths.append(__A   )
      for node in graph[start]:
            if tuple(__A   ) not in path:
                  my_dfs(__A				,      tuple(__A   )				,      __A				,      __A   )







def _UpperCamelCase	(					__A				,      __A				,      __A   )							->		Union[str, Any]:


      '''simple docstring'''



      UpperCamelCase__  =    int(s / 100 * (len(__A   ) - 1)   )
      for i in cluster[k]:
            my_dfs(__A				,      tuple(cluster[k][i]   )				,      (["Header"],)   )







def _UpperCamelCase	(					__A   )							->		Optional[Any]:


      '''simple docstring'''



      UpperCamelCase__  =    []
      for edges in paths:
            UpperCamelCase__  =    []
            for j in range(len(__A   ) - 1   ):
                  UpperCamelCase__  =    list(edges[j]   )
                  for e in temp:
                        UpperCamelCase__  =    (e[0], e[1])
                        el.append(__A   )
            freq_sub_el.append(__A   )
      return freq_sub_el







def _UpperCamelCase	(					__A   )							->		Optional[int]:


      '''simple docstring'''



      for i in range(len(__A   )   ):
            for j in range(len(edge_array[i]   )   ):
                  UpperCamelCase__  =    edge_array[i][j].split("-"   )
                  UpperCamelCase__  =    t


if __name__ == "__main__":
  preprocess(edge_array)
  a__  : List[Any]				=	get_frequency_table(edge_array)
  a__  : Optional[int]				=	get_nodes(frequency_table)
  a__  : Any				=	get_cluster(nodes)
  a__  : Tuple				=	get_support(cluster)
  a__  : str				=	construct_graph(cluster, nodes)
  find_freq_subgraph_given_support(6_0, cluster, graph)
  a__  : list				=	[]
  a__  : str				=	freq_subgraphs_edge_list(paths)
  print_all()





