def test_train_shortest_path():
graphs = [
generate_shorest_path_example(100, 0.01, 1000) for _ in range(10)
]
input_data = [
GraphData.from_networkx(g, feature_key="_features") for g in graphs
]
target_data = [
GraphData.from_networkx(g, feature_key="_target") for g in graphs
]
loader = GraphDataLoader(input_data,
target_data,
batch_size=32,
shuffle=True)
agg = lambda: Flex(MultiAggregator)(Flex.d(),
["add", "mean", "max", "min"])
network = Network()
for input_batch, _ in loader:
network(input_batch, 10)
break
loss_fn = torch.nn.BCELoss()
optimizer = torch.optim.AdamW(network.parameters())
for _ in range(10):
for input_batch, target_batch in loader:
output = network(input_batch, 10)[0]
x, y = output.x, target_batch.x
loss = loss_fn(x.flatten(), y[:, 0].flatten())
loss.backward()
print(loss.detach())
optimizer.step()
def test_generate_shortest_path_example():
g = generate_shorest_path_example(100, 0.01, 10)
for n, ndata in g.nodes(data=True):
assert "source" in ndata
assert "target" in ndata
d1 = GraphData.from_networkx(g, feature_key="_features")
d2 = GraphData.from_networkx(g, feature_key="_target")
assert tuple(d1.shape) == (4, 1, 1)
assert tuple(d2.shape) == (2, 2, 1)
def test_from_networkx_no_edge(self, keys):
kwargs = {"feature_key": "features", "global_attr_key": "data"}
feature_key, global_attr_key = keys
if feature_key is not None:
kwargs["feature_key"] = feature_key
else:
del kwargs["feature_key"]
if global_attr_key is not None:
kwargs["global_attr_key"] = global_attr_key
else:
del kwargs["global_attr_key"]
fkey = kwargs.get("feature_key", "features")
gkey = kwargs.get("global_attr_key", None)
g = nx.OrderedMultiDiGraph()
g.add_node("node1", **{fkey: np.random.randn(5)})
g.add_node("node2", **{fkey: np.random.randn(5)})
g.ordered_edges = []
# g.add_edge('node1', 'node2', **{fkey: torch.randn(4)})
g.set_global({fkey: np.random.randn(3)}, gkey)
data = GraphData.from_networkx(g, **kwargs)
Comparator.data_to_nx(data, g, fkey, gkey)
def sigmoid_circuit(cls, data_size, batch_size):
import math
def func(x):
return 1 - 1.0 / (1 + math.exp(-x))
input_data = []
output_data = []
for _ in range(data_size):
n_size = np.random.randint(2, 20)
tree = nx.random_tree(n_size)
# randomize node directions
g = nx.DiGraph()
for n1, n2, edata in tree.edges(data=True):
i = np.random.randint(2)
if i % 2 == 0:
g.add_edge(n1, n2)
else:
g.add_edge(n2, n1)
cls._default_g(g)
for n in nx_utils.iter_roots(g):
ndata = g.nodes[n]
ndata["target"] = np.array(10.0)
for n in nx.topological_sort(g):
ndata = g.nodes[n]
if "target" not in ndata:
incoming = []
for p in g.predecessors(n):
pdata = g.nodes[p]
incoming.append(pdata["target"])
incoming = np.concatenate(incoming)
i = incoming.sum()
o = func(i)
ndata["target"] = o
input_data.append(
GraphData.from_networkx(g, feature_key="features"))
output_data.append(GraphData.from_networkx(g,
feature_key="target"))
return GraphDataLoader(list(zip(input_data, output_data)),
batch_size=batch_size)
def test_from_networkx_missing_glob_data(self):
g = nx.DiGraph()
g.add_node(1, feature=np.array([10.0]))
g.add_node(2, feature=np.array([11.0]))
g.add_edge(1, 2, feature=np.array([12.0]))
data = GraphData.from_networkx(g, feature_key="feature")
assert torch.all(data.x == torch.tensor([[10.0], [11.0]]))
assert torch.all(data.e == torch.tensor([[12.0]]))
assert data.g.shape == (1, 0)
def test_from_networkx_missing_node_data(self):
g = nx.DiGraph()
g.add_node(1)
g.add_edge(1, 2, feature=np.array([10.0]))
g.set_global({"feature": np.array([12.0])})
data = GraphData.from_networkx(g, feature_key="feature")
assert data.x.shape == (2, 0)
assert torch.all(data.e == torch.tensor([[10.0]]))
assert torch.all(data.g == torch.tensor([[12.0]]))
def boolean_network(cls, data_size, batch_size):
input_data = []
output_data = []
for _ in range(data_size):
n_size = np.random.randint(2, 20)
tree = nx.random_tree(n_size)
# randomize node directions
g = nx.DiGraph()
for n1, n2, edata in tree.edges(data=True):
i = np.random.randint(2)
if i % 2 == 0:
g.add_edge(n1, n2)
else:
g.add_edge(n2, n1)
cls._default_g(g)
for n in nx_utils.iter_roots(g):
ndata = g.nodes[n]
ndata["target"] = np.array([1.0])
for n in nx.topological_sort(g):
ndata = g.nodes[n]
if "target" not in ndata:
incoming = []
for p in g.predecessors(n):
pdata = g.nodes[p]
incoming.append(pdata["target"])
incoming = np.concatenate(incoming)
i = incoming.max()
if i == 1:
o = np.array([0.0])
else:
o = np.array([1.0])
ndata["target"] = o
input_data.append(
GraphData.from_networkx(g, feature_key="features"))
output_data.append(GraphData.from_networkx(g,
feature_key="target"))
return GraphDataLoader(list(zip(input_data, output_data)),
batch_size=batch_size)
def est_density(cls, data_size, batch_size):
input_data = []
output_data = []
s = 2
for _ in range(data_size):
n_size = np.random.randint(2, 20)
g = nx.to_directed(nx.random_tree(n_size))
cls._default_g(g)
gdata = g.get_global()
gdata["features"] = np.random.randn(1)
gdata["target"] = np.array([nx.density(g)])
input_data.append(
GraphData.from_networkx(g, feature_key="features"))
output_data.append(GraphData.from_networkx(g,
feature_key="target"))
return GraphDataLoader(input_data, output_data, batch_size=batch_size)
def in_degree(cls, data_size, batch_size):
input_data = []
output_data = []
s = 2
for _ in range(data_size):
n_size = np.random.randint(2, 20)
g = nx.to_directed(nx.random_tree(n_size))
cls._default_g(g)
for n, ndata in g.nodes(data=True):
ndata["features"] = np.random.randn(1)
ndata["target"] = np.array([g.in_degree(n)])
input_data.append(
GraphData.from_networkx(g, feature_key="features"))
output_data.append(GraphData.from_networkx(g,
feature_key="target"))
return GraphDataLoader(list(zip(input_data, output_data)),
batch_size=batch_size)
def random_graph_red_black_edges(cls, data_size, batch_size):
input_data = []
output_data = []
s = 2
for _ in range(data_size):
g = nx.to_directed(nx.random_tree(10))
cls._default_g(g)
for _, _, edata in g.edges(data=True):
i = np.random.randint(0, 1, (1, ))
edata["features"] = to_one_hot(i, s)
if i % 2 == 0:
target = np.array([0.5])
else:
target = np.zeros((1, ))
edata["target"] = target
input_data.append(
GraphData.from_networkx(g, feature_key="features"))
output_data.append(GraphData.from_networkx(g,
feature_key="target"))
return GraphDataLoader(input_data, output_data, batch_size=batch_size)
def grid_data(request):
def newg(g):
return nx_random_features(g, 5, 4, 3)
if request.param is GraphData:
g = nx_to_directed(newg(nx.grid_graph([2, 4, 3])))
return GraphData.from_networkx(g)
elif request.param is GraphBatch:
graphs = [
nx_to_directed(newg(nx.grid_graph([2, 4, 3]))) for _ in range(10)
]
return GraphBatch.from_networkx_list(graphs)
else:
raise ValueError()
def test_from_networkx_different_edge_shapes(self):
g = nx.DiGraph()
g.add_edge(1, 2, feature=np.array([[10.0, 11.0]]))
g.add_edge(2, 3, feature=np.array([[10.0], [11.0]]))
with pytest.raises(RuntimeError):
GraphData.from_networkx(g, feature_key="feature")
def test_empty_networkx(self):
"""Empty graphs should be OK."""
g = nx.DiGraph()
GraphData.from_networkx(g)
def test_from_networkx_types(self, cls):
g = cls()
GraphData.from_networkx(g)
