skyfall-xzz / subgraph_enumeration Goto Github PK

from subgraph_enumeration.data_structures.graph import Graph
from subgraph_enumeration.data_structures.enumeration import CalculateAscendingEnumerationIndex
from subgraph_enumeration.utilities.dataIO import WriteGraph


# @param identifier is a unique string that will be used to differentiate this graph from others.
# Note, this identifier should be globally unique - files will be saved in set locations 
# based on the string value.
# @param directed is a boolean for if edges are directed.
# @param vertex_colored is a boolean for if the vertices have labels or colors.
# @param edge_colored is a boolean for if the edges have labels or colors.

graph = Graph(identifier, directed, vertex_colored, edge_colored)

# add vertices 
for enumeration_index, (neuron, neuron_type) in enumerate(sorted(neurons)):
    # @param neuron: a unique integer identifier for this neuron.
    # @param enumeration_index: the enumeration order (will be optimized later).
    # @param community: what brain region or community the neuron belongs to (default = -1).
    # @param color: the label for the neuron as an integer (strings can be assigned to types later).
    graph.AddVertex(neuron, enumeration_index, community = -1, color = neuron_type)

# add edges
for (pre_neuron_id, post_neuron_id, weight, edge_type) in edges:
    # @param pre_neuron_id: the source node (neuron).
    # @param post_neuron_id: the destination node (neuron).
    # @param weight: the weight of the edge (number of synapses or perceived strength)
    # @param edge_type: the label for the edge as an integer (strings can be assigned to types later).
    graph.AddEdge(pre_neuron_id, post_neuron_id, weight, edge_type)

# these keys correspond to the neuron_type integers above 
vertex_type_mapping = {
    0: 'glial_cell', 
    1: 'end_organ',
    .
    . 
    .
}

# these keys correspond to the edge type integers above 
edge_type_mapping = {
    0: 'excitatory', 
    1: 'inhibitory',
}

graph.SetVertexTypeMapping(vertex_type_mapping)
graph.SetEdgeTypeMapping(edge_type_mapping)

# where to save the file (should end with bz2 for significant space savings)
output_filename = 'graphs/connectome.graph.bz2'
WriteGraph(graph, output_filename)

# recalculate the enumeration index based on methods discussed in paper
# @param graph: the graph data structure created above 
# @param method: should always be minimum (optimal heuristic found)
CalculateAscendingEnumerationIndex(graph, 'minimum')

from subgraph_enumeration.kavosh.enumerate import EnumerateSubgraphsSequentially, CombineEnumeratedSubgraphs

# Call both functions to enumerate subgraphs sequentially.
# @param filename: the location of the graph.bz2 file. It is best to use the created 
# graph from running CalculateAscendingEnumerationIndex.
# @param k: the integer size of the subgraphs to identify.
# @param vertex_color: boolean for motif discovery with vertex colors.
# @param edge_colors: boolean for motif discovery with edge colors.
# @param community: boolean for motif discovery with community divide-and-conquer.
# Note, either vertex color or edge colors may be True, but not both. They can both be false.

EnumerateSubgraphsSequentially(filename, k, vertex_colored, edge_colored, community_based)
CombineEnumeratedSubgraphs(filename, k, vertex_colored, edge_colored, community_based)

from subgraph_enumeration.kavosh.enumerate import EnumerateSubgraphsFromNodes

# @param filename: the location of the graph.bz2 file. 
# It is best to use the created graph from running CalculateAscendingEnumerationIndex.
# @param k: the integer size of the subgraphs to identify.
# @param nodes: the neuron ids to enumerate from.
# @param output_suffix: a unique string identifier for this parallel call. 
# Files are created based on this identifier. Do not use the same identifier for 
# different threads for the same filename.
# @param vertex_color: boolean for motif discovery with vertex colors.
# @param edge_colors: boolean for motif discovery with edge colors.
# @param community: boolean for motif discovery with community divide-and-conquer.
# Note, either vertex color or edge colors may be True, but not both. They can both be false.

EnumerateSubgraphsFromNodes(filename, k, nodes, output_suffix, vertex_colored, edge_colored, community_based)

from subgraph_enumeration.kavosh.enumerate import CombineEnumeratedSubgraphs

CombineEnumeratedSubgraphs(filename, k, vertex_colored, edge_colored, community_based)

# Read the graph
from subgraph_enumeration.utilities.dataIO import ReadGraph

# if enumeration did not include vertex colors, you can add an optional parameter 
# of header_only = True to increase speed.
graph = ReadGraph('connectome-minimum.graph.bz2')

from subgraph_enumeration.kavosh.classify import ParseCertificate

# @param graph: a graph data structure object.
# @param k: the integer size of the motifs.
# @param certificate: the string certificate from Nauty to parse
# @param vertex_colored: boolean for neuron labels or types.
# @param edge_colored: boolean for edge labels or types.
# @param directed: boolean for if the graph is directed.
result = ParseCertificate(graph, k, certificate, vertex_colored, edge_colored, directed)
print(result)