


lowerCAmelCase__						:Union[str, Any]         =							[
    ['''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  lowerCAmelCase__				(    a__:	Optional[int] )						->	Union[str, Any]:


							'''simple docstring'''





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

def  lowerCAmelCase__				(    a__:	int    ,						a__:	Union[str, Any] )						->	List[str]:


							'''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  lowerCAmelCase__				(    a__:	Optional[int] )						->	Optional[int]:


							'''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  lowerCAmelCase__				(    a__:	Dict )						->	str:


							'''simple docstring'''





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

def  lowerCAmelCase__				(    a__:	Dict )						->	Optional[Any]:


							'''simple docstring'''





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

def  lowerCAmelCase__				(    a__:	int )						->	Dict:


							'''simple docstring'''





							return [i * 1_0_0 / len(a__ ) for i in cluster]

def  lowerCAmelCase__				(    )						->	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  lowerCAmelCase__				(    a__:	Dict    ,						a__:	Any    ,						a__:	Union[str, Any]    ,						a__:	int )						->	Dict:


							'''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  lowerCAmelCase__				(    a__:	Any    ,						a__:	List[Any] )						->	Dict:


							'''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  lowerCAmelCase__				(    a__:	Optional[int]    ,						a__:	Union[str, Any]    ,						a__:	Optional[Any]    ,						a__:	str=None )						->	Union[str, Any]:


							'''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  lowerCAmelCase__				(    a__:	Optional[Any]    ,						a__:	Optional[int]    ,						a__:	Tuple )						->	Tuple:


							'''simple docstring'''





							_UpperCAmelCase					=    int(s / 1_0_0 * (len(a__ ) - 1) )
							for i in cluster[k]:
														my_dfs(a__    ,						tuple(cluster[k][i] )    ,						(['Header'],) )

def  lowerCAmelCase__				(    a__:	Union[str, Any] )						->	str:


							'''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  lowerCAmelCase__				(    a__:	Tuple )						->	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)
		lowerCAmelCase__						:Optional[int]         =							get_frequency_table(edge_array)
		lowerCAmelCase__						:List[Any]         =							get_nodes(frequency_table)
		lowerCAmelCase__						:List[Any]         =							get_cluster(nodes)
		lowerCAmelCase__						:Tuple         =							get_support(cluster)
		lowerCAmelCase__						:Any         =							construct_graph(cluster, nodes)
		find_freq_subgraph_given_support(6_0, cluster, graph)
		lowerCAmelCase__						:list         =							[]
		lowerCAmelCase__						:Dict         =							freq_subgraphs_edge_list(paths)
		print_all()




import inspect
import unittest

from transformers import ResNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
		import jax
		import jax.numpy as jnp

		from transformers.models.resnet.modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel

if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor

class 	__a   (       unittest.TestCase    ):
		def __init__(    self    ,					_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE=3    ,					_SCREAMING_SNAKE_CASE=32    ,					_SCREAMING_SNAKE_CASE=3    ,					_SCREAMING_SNAKE_CASE=10    ,					_SCREAMING_SNAKE_CASE=[10, 20, 30, 40]    ,					_SCREAMING_SNAKE_CASE=[1, 1, 2, 1]    ,					_SCREAMING_SNAKE_CASE=True    ,					_SCREAMING_SNAKE_CASE=True    ,					_SCREAMING_SNAKE_CASE="relu"    ,					_SCREAMING_SNAKE_CASE=3    ,					_SCREAMING_SNAKE_CASE=None    ,					)				-> Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=    parent
									_UpperCAmelCase					=    batch_size
									_UpperCAmelCase					=    image_size
									_UpperCAmelCase					=    num_channels
									_UpperCAmelCase					=    embeddings_size
									_UpperCAmelCase					=    hidden_sizes
									_UpperCAmelCase					=    depths
									_UpperCAmelCase					=    is_training
									_UpperCAmelCase					=    use_labels
									_UpperCAmelCase					=    hidden_act
									_UpperCAmelCase					=    num_labels
									_UpperCAmelCase					=    scope
									_UpperCAmelCase					=    len(_SCREAMING_SNAKE_CASE		)
		def 			UpperCAmelCase__       (    self		)				-> List[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

									_UpperCAmelCase					=    self.get_config()

									return config, pixel_values
		def 			UpperCAmelCase__       (    self		)				-> Union[str, Any]:




									"""simple docstring"""





									return ResNetConfig(
									    num_channels=self.num_channels    ,					embeddings_size=self.embeddings_size    ,					hidden_sizes=self.hidden_sizes    ,					depths=self.depths    ,					hidden_act=self.hidden_act    ,					num_labels=self.num_labels    ,					image_size=self.image_size    ,					)
		def 			UpperCAmelCase__       (    self    ,					_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE		)				-> Optional[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=    FlaxResNetModel(config=_SCREAMING_SNAKE_CASE		)
									_UpperCAmelCase					=    model(_SCREAMING_SNAKE_CASE		)

									# Output shape (b, c, h, w)
									self.parent.assertEqual(
									    result.last_hidden_state.shape    ,					(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)    ,					)
		def 			UpperCAmelCase__       (    self    ,					_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE		)				-> Any:




									"""simple docstring"""





									_UpperCAmelCase					=    self.num_labels
									_UpperCAmelCase					=    FlaxResNetForImageClassification(config=_SCREAMING_SNAKE_CASE		)
									_UpperCAmelCase					=    model(_SCREAMING_SNAKE_CASE		)
									self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.num_labels)		)






		def 			UpperCAmelCase__       (    self		)				-> Any:




									"""simple docstring"""





									_UpperCAmelCase					=    self.prepare_config_and_inputs()
									_UpperCAmelCase	, _UpperCAmelCase					=    config_and_inputs
									_UpperCAmelCase					=    {'pixel_values': pixel_values}
									return config, inputs_dict



@require_flax
class 	__a   (       UpperCAmelCase					,   unittest.TestCase    ):
		_a			:						Any    			=			(FlaxResNetModel, FlaxResNetForImageClassification) if is_flax_available() else ()

		_a			:						Dict    			=			False
		_a			:						Optional[Any]    			=			False
		_a			:						Optional[Any]    			=			False
		def 			UpperCAmelCase__       (    self		)				-> None:




									"""simple docstring"""





									_UpperCAmelCase					=    FlaxResNetModelTester(self		)
									_UpperCAmelCase					=    ConfigTester(self    ,					config_class=_SCREAMING_SNAKE_CASE    ,					has_text_modality=_SCREAMING_SNAKE_CASE		)
		def 			UpperCAmelCase__       (    self		)				-> str:




									"""simple docstring"""





									self.create_and_test_config_common_properties()
									self.config_tester.create_and_test_config_to_json_string()
									self.config_tester.create_and_test_config_to_json_file()
									self.config_tester.create_and_test_config_from_and_save_pretrained()
									self.config_tester.create_and_test_config_with_num_labels()
									self.config_tester.check_config_can_be_init_without_params()
									self.config_tester.check_config_arguments_init()
		def 			UpperCAmelCase__       (    self		)				-> int:




									"""simple docstring"""





									return
		def 			UpperCAmelCase__       (    self		)				-> Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE		)
		def 			UpperCAmelCase__       (    self		)				-> List[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE		)
		@unittest.skip(reason='ResNet does not use inputs_embeds'		)
		def 			UpperCAmelCase__       (    self		)				-> Optional[Any]:




									"""simple docstring"""





									pass
		@unittest.skip(reason='ResNet does not support input and output embeddings'		)
		def 			UpperCAmelCase__       (    self		)				-> Optional[int]:




									"""simple docstring"""





									pass
		def 			UpperCAmelCase__       (    self		)				-> Dict:




									"""simple docstring"""





									_UpperCAmelCase	, _UpperCAmelCase					=    self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																_UpperCAmelCase					=    model_class(_SCREAMING_SNAKE_CASE		)
																_UpperCAmelCase					=    inspect.signature(model.__call__		)
																# signature.parameters is an OrderedDict => so arg_names order is deterministic
																_UpperCAmelCase					=    [*signature.parameters.keys()]

																_UpperCAmelCase					=    ['pixel_values']
																self.assertListEqual(arg_names[:1]    ,					_SCREAMING_SNAKE_CASE		)
		def 			UpperCAmelCase__       (    self		)				-> int:




									"""simple docstring"""





									def check_hidden_states_output(_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE		):
																_UpperCAmelCase					=    model_class(_SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase					=    model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE		)		)

																_UpperCAmelCase					=    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																_UpperCAmelCase					=    self.model_tester.num_stages
																self.assertEqual(len(_SCREAMING_SNAKE_CASE		)    ,					expected_num_stages + 1		)
		@unittest.skip(reason='ResNet does not use feedforward chunking'		)
		def 			UpperCAmelCase__       (    self		)				-> List[Any]:




									"""simple docstring"""





									pass






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




									"""simple docstring"""





									_UpperCAmelCase	, _UpperCAmelCase					=    self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																with self.subTest(model_class.__name__		):
																							_UpperCAmelCase					=    self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE		)
																							_UpperCAmelCase					=    model_class(_SCREAMING_SNAKE_CASE		)

																							@jax.jit
																							def model_jitted(_SCREAMING_SNAKE_CASE    ,					**_SCREAMING_SNAKE_CASE		):
																														return model(pixel_values=_SCREAMING_SNAKE_CASE    ,					**_SCREAMING_SNAKE_CASE		)

																							with self.subTest('JIT Enabled'		):
																														_UpperCAmelCase					=    model_jitted(**_SCREAMING_SNAKE_CASE		).to_tuple()

																							with self.subTest('JIT Disabled'		):
																														with jax.disable_jit():
																																					_UpperCAmelCase					=    model_jitted(**_SCREAMING_SNAKE_CASE		).to_tuple()

																							self.assertEqual(len(_SCREAMING_SNAKE_CASE		)    ,					len(_SCREAMING_SNAKE_CASE		)		)
																							for jitted_output, output in zip(_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE		):
																														self.assertEqual(jitted_output.shape    ,					output.shape		)



def  lowerCAmelCase__				(    )						->	Optional[int]:


							'''simple docstring'''





							_UpperCAmelCase					=    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
							return image







@require_flax
class 	__a   (       unittest.TestCase    ):
		@cached_property
		def 			UpperCAmelCase__       (    self		)				-> List[str]:




									"""simple docstring"""





									return AutoImageProcessor.from_pretrained('microsoft/resnet-50'		) if is_vision_available() else None






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




									"""simple docstring"""





									_UpperCAmelCase					=    FlaxResNetForImageClassification.from_pretrained('microsoft/resnet-50'		)

									_UpperCAmelCase					=    self.default_image_processor
									_UpperCAmelCase					=    prepare_img()
									_UpperCAmelCase					=    image_processor(images=_SCREAMING_SNAKE_CASE    ,					return_tensors='np'		)

									_UpperCAmelCase					=    model(**_SCREAMING_SNAKE_CASE		)

									# verify the logits
									_UpperCAmelCase					=    (1, 1000)
									self.assertEqual(outputs.logits.shape    ,					_SCREAMING_SNAKE_CASE		)

									_UpperCAmelCase					=    jnp.array([-11.1069, -9.7877, -8.3777]		)

									self.assertTrue(jnp.allclose(outputs.logits[0, :3]    ,					_SCREAMING_SNAKE_CASE    ,					atol=1e-4		)		)
