def test_RGCN_apply_dense_directed():
    G, features = create_graph_features(is_directed=True)

    As = get_As(G)
    As = [np.expand_dims(A.todense(), 0) for A in As]

    generator = RelationalFullBatchNodeGenerator(G, sparse=False)
    rgcnModel = RGCN([2],
                     generator,
                     num_bases=10,
                     activations=["relu"],
                     dropout=0.5)
    x_in, x_out = rgcnModel.in_out_tensors()
    model = keras.Model(inputs=x_in, outputs=x_out)

    # Check fit method
    out_indices = np.array([[0, 1]], dtype="int32")
    preds_1 = model.predict([features[None, :, :], out_indices] + As)
    assert preds_1.shape == (1, 2, 2)

    # Check fit method
    preds_2 = model.predict(generator.flow(["a", "b"]))
    assert preds_2.shape == (1, 2, 2)

    assert preds_1 == pytest.approx(preds_2)
Exemple #2
0
def test_RGCN_apply_sparse_directed():
    G, features = create_graph_features(is_directed=True)

    As = get_As(G)
    As = [A.tocoo() for A in As]

    A_indices = [
        np.expand_dims(np.hstack((A.row[:, None], A.col[:, None])), 0) for A in As
    ]
    A_values = [np.expand_dims(A.data, 0) for A in As]

    generator = RelationalFullBatchNodeGenerator(G, sparse=True)
    rgcnModel = RGCN([2], generator, num_bases=10, activations=["relu"], dropout=0.5)

    x_in, x_out = rgcnModel.build()
    model = keras.Model(inputs=x_in, outputs=x_out)

    # Check fit method
    out_indices = np.array([[0, 1]], dtype="int32")
    preds_1 = model.predict([features[None, :, :], out_indices] + A_indices + A_values)
    assert preds_1.shape == (1, 2, 2)

    # Check fit_generator method
    preds_2 = model.predict_generator(generator.flow(["a", "b"]))
    assert preds_2.shape == (1, 2, 2)

    assert preds_1 == pytest.approx(preds_2)
Exemple #3
0
def test_RGCN_init():
    G, features = create_graph_features()

    generator = RelationalFullBatchNodeGenerator(G)
    rgcnModel = RGCN([2], generator, num_bases=10, activations=["relu"], dropout=0.5)

    assert rgcnModel.layer_sizes == [2]
    assert rgcnModel.activations == ["relu"]
    assert rgcnModel.dropout == 0.5
    assert rgcnModel.num_bases == 10
def test_kernel_and_bias_defaults():
    graph, _ = create_graph_features()
    generator = RelationalFullBatchNodeGenerator(graph, sparse=False)
    rgcn = RGCN([2, 2], generator, num_bases=10)
    for layer in rgcn._layers:
        if isinstance(layer, RelationalGraphConvolution):
            assert isinstance(layer.kernel_initializer,
                              tf.initializers.GlorotUniform)
            assert isinstance(layer.bias_initializer, tf.initializers.Zeros)
            assert layer.kernel_regularizer is None
            assert layer.bias_regularizer is None
            assert layer.kernel_constraint is None
            assert layer.bias_constraint is None
Exemple #5
0
def test_RGCN_save_load(tmpdir, num_bases, sparse):
    graph, _ = create_graph_features()
    generator = RelationalFullBatchNodeGenerator(graph, sparse=sparse)
    rgcn = RGCN([2, 2], generator, num_bases=num_bases)
    test_utils.model_save_load(tmpdir, rgcn)