data/simple_graph/create_graph.py

import networkx as nx
import random
import os
import argparse
import numpy

def generate_random_directed_graph(num_nodes, edge_prob):
    # Create an empty directed graph
    G = nx.DiGraph()
    
    # Add nodes to the graph
    for i in range(num_nodes):
        G.add_node(i)
    
    # Add edges to the graph based on the probability
    for i in range(num_nodes):
        for j in range(num_nodes):
            if DAG:
                if i < j and random.random() < edge_prob: 
                    G.add_edge(i, j)
            else:
                if i != j and random.random() < edge_prob:
                    G.add_edge(i, j)
    return G

def get_reachable_nodes(G, target_node):  
    # Get the transitive closure of the graph  
    TC = nx.transitive_closure(G)  
    # Find the predecessors in the transitive closure (nodes that can reach the target_node)  
    reachable_from = TC.predecessors(target_node)  
    return list(reachable_from)

def obtain_reachability():
    reachability = {}  
    pairs = 0
    for node in random_digraph.nodes():  
        reachability[node] = get_reachable_nodes(random_digraph, node)
        pairs += len(reachability[node])
    return reachability, pairs

def random_walk(source_node, target_node):
    stack = [source_node]
    visited = [] # to eliminate cycles

    while stack != []:
        cur_node = stack.pop()
        visited.append(cur_node)
        if cur_node == target_node:
            return visited

        adj = list(random_digraph.successors(cur_node))
        anc = list(reachability[target_node])
        anc.append(target_node)
        
        remaining = [element for element in adj if element in anc and element not in visited] #if we want the path to contain cycles, we should remove "and element not in visited"
    
        if len(remaining) == 0:
            return random_walk(source_node, target_node) # for non-DAGs

        next_node = random.choice(remaining)
        stack.append(next_node)

    return visited

def create_dataset(i):
    train_set = []
    test_set = []
    train_num_per_pair = max(i,1)
    for target_node in range(num_nodes):
        cnt = 0 # to avoid some target not appear in training dataset
        for source_node in range(target_node):
            if (data[source_node][target_node] == 1):
                if random_digraph.has_edge(source_node, target_node):
                    train_set.append([source_node, target_node,source_node, target_node])
                for ii in range(train_num_per_pair):
                    train_set.append([source_node, target_node] + random_walk(source_node, target_node) )
            if (data[source_node][target_node] == -1):
                test_set.append([source_node, target_node] + random_walk(source_node, target_node))
                    
    return train_set, test_set

def add_x(train_set, test_set):
    cnt = 0
    for target_node in range(num_nodes):
        for source_node in range(target_node):
            if source_node not in reachability[target_node]:
                cnt += 1

    prob_in_test = len(test_set) / cnt * 0.2
    prob_in_train = min(len(train_set) / cnt * 0.2, 1 - prob_in_test)
    train_repeat = max(int(len(train_set) / cnt * 0.15 / prob_in_train), 1)
    print(prob_in_train, prob_in_test, train_repeat)

    for target_node in range(num_nodes):
        for source_node in range(target_node):
            if source_node not in reachability[target_node]:
                coin = random.random()
                if coin < prob_in_train:
                    for _ in range(train_repeat):
                        train_set.append([source_node, target_node, 'x'])
                        
                elif coin > 1 - prob_in_test:
                    test_set.append([source_node, target_node, 'x'])

    return train_set, test_set

def obtain_stats(dataset):
    max_len = 0
    pairs = set()

    for data in dataset:
        max_len = max(max_len, len(data))
        pairs.add((data[0],data[-1]))

    len_stats = [0]*(max_len + 1) 
    
    for data in dataset:
        length = len(data)
        len_stats[length] += 1
        
    print('number of source target pairs:', len(pairs))
    for ii in range(3, len(len_stats)):
        print(f'There are {len_stats[ii]} paths with length {ii-3}')


def format_data(data):
    return f"{data[0]} {data[1]} " + ' '.join(str(num) for num in data[2:])  + '\n'
        
def write_dataset(dataset, file_name):
    with open(file_name, "w") as file:
        for data in dataset:
            file.write(format_data(data))


if __name__ == "__main__":  
    parser = argparse.ArgumentParser(description='Generate a random graph based on the given parameters.')  
    parser.add_argument('--num_nodes', type=int, default=100, help='Number of nodes in the graph')  
    parser.add_argument('--edge_prob', type=float, default=0.1, help='Probability of creating an edge between two nodes')  
    parser.add_argument('--DAG', type=bool, default=True, help='Whether the graph should be a Directed Acyclic Graph')  
    parser.add_argument('--chance_in_train', type=float, default=0.5, help='Chance of a pair being in the training set')  
    parser.add_argument('--num_of_paths', type=int, default=20, help='Number of paths per pair nodes in training dataset')  

    args = parser.parse_args()  

    num_nodes = args.num_nodes
    edge_prob = args.edge_prob
    DAG = args.DAG
    chance_in_train = args.chance_in_train
    num_of_paths = args.num_of_paths

    random_digraph = generate_random_directed_graph(num_nodes, edge_prob)
    reachability, feasible_pairs = obtain_reachability()

    folder_name = os.path.join(os.path.dirname(__file__), f'{num_nodes}')
    if not os.path.exists(folder_name):  
        os.makedirs(folder_name)

    data = numpy.zeros([num_nodes,num_nodes])
    for target_node in range(num_nodes):
        cnt = 0 # to avoid some target not appear in training dataset
        for source_node in range(target_node):
            if source_node in reachability[target_node]:
                if (random_digraph.has_edge(source_node, target_node)) or random.random() < chance_in_train or cnt < 1:
                    data[source_node][target_node] = 1
                    cnt += 1 
                else:
                    data[source_node][target_node] = -1
                #if (random_digraph.has_edge(source_node, target_node)):
                #    data[source_node][target_node] = 1
                #else:
                #    data[source_node][target_node] = -1
                
    train_set, test_set = create_dataset(num_of_paths)
        
    obtain_stats(train_set)
    print('number of source target pairs:', len(test_set))

    write_dataset(train_set, os.path.join(os.path.dirname(__file__), f'{num_nodes}/train_{num_of_paths}.txt') )
    write_dataset(test_set, os.path.join(os.path.dirname(__file__),  f'{num_nodes}/test.txt') )
    nx.write_graphml(random_digraph, os.path.join(os.path.dirname(__file__), f'{num_nodes}/path_graph.graphml') )