示例#1
0
#!/usr/bin/env python
# coding: utf-8

import torch
import graphgallery

print("GraphGallery version: ", graphgallery.__version__)
print("Torch version: ", torch.__version__)
'''
Load Datasets
- cora/citeseer/pubmed
'''
from graphgallery.datasets import Planetoid
data = Planetoid('cora', root="~/GraphData/datasets/", verbose=False)
graph = data.graph
splits = data.split_nodes()

graphgallery.set_backend("pytorch")

from graphgallery.gallery import PPNP
trainer = PPNP(graph, device="gpu",
               seed=123).process(attr_transform="normalize_attr").build()
his = trainer.train(splits.train_nodes,
                    splits.val_nodes,
                    verbose=1,
                    epochs=100)
results = trainer.test(splits.test_nodes)
print(f'Test loss {results.loss:.5}, Test accuracy {results.accuracy:.2%}')
示例#2
0
import numpy as np
import graphgallery as gg
from graphgallery import functional as gf
from graphgallery.datasets import NPZDataset

data = NPZDataset('cora',
                  root="~/GraphData/datasets/",
                  verbose=False,
                  transform="standardize")
graph = data.graph
splits = data.split_nodes(random_state=15)

# use PyTorch backend
gg.set_backend("torch")

# GPU is recommended
device = "gpu"

################### Surrogate model ############################
trainer = gg.gallery.nodeclas.GCN(device=device,
                                  seed=None).make_data(graph).build()
his = trainer.fit(splits.train_nodes, splits.val_nodes, verbose=1, epochs=200)

################### Attacker model ############################
unlabeled_nodes = np.hstack([splits.val_nodes, splits.test_nodes])
self_training_labels = trainer.predict(unlabeled_nodes).argmax(1)

attacker = gg.attack.untargeted.Metattack(
    graph, device=device, seed=123).process(
        splits.train_nodes,
        unlabeled_nodes,
示例#3
0
#!/usr/bin/env python
# coding: utf-8

import torch
import dgl
import graphgallery

print("GraphGallery version: ", graphgallery.__version__)
print("Torch version: ", torch.__version__)
print("DGL version: ", dgl.__version__)

'''
Load Datasets
- cora/citeseer/pubmed
'''
from graphgallery.datasets import Planetoid
data = Planetoid('cora', root="~/GraphData/datasets/", verbose=False)
graph = data.graph
splits = data.split_nodes()

graphgallery.set_backend("dgl")

from graphgallery.gallery.nodeclas import GAT
trainer = GAT(device="gpu", seed=123).make_data(graph, attr_transform="normalize_attr").build()
his = trainer.fit(splits.train_nodes, splits.val_nodes, verbose=1, epochs=200)
results = trainer.evaluate(splits.test_nodes)
print(f'Test loss {results.loss:.5}, Test accuracy {results.accuracy:.2%}')
示例#4
0
#!/usr/bin/env python
# coding: utf-8

import torch
import graphgallery
import torch_geometric

print("GraphGallery version: ", graphgallery.__version__)
print("Torch version: ", torch.__version__)
print("Torch_Geometric version: ", torch_geometric.__version__)
'''
Load Datasets
- cora/citeseer/pubmed
'''
from graphgallery.datasets import Planetoid
data = Planetoid('cora', root="~/GraphData/datasets/", verbose=False)
graph = data.graph
splits = data.split_nodes()

graphgallery.set_backend("pyg")

from graphgallery.gallery import SGC
model = SGC(graph, attr_transform="normalize_attr", device="gpu", seed=123)
model.build()
his = model.train(splits.train_nodes, splits.val_nodes, verbose=1, epochs=100)
results = model.test(splits.test_nodes)
print(f'Test loss {results.loss:.5}, Test accuracy {results.accuracy:.2%}')
示例#5
0
import graphgallery as gg
from graphgallery import functional as gf

gg.set_memory_growth()

from graphgallery.datasets import Planetoid, NPZDataset
data = NPZDataset('cora',
                  root="~/GraphData/datasets/",
                  verbose=False,
                  transform='standardize')

graph = data.graph
splits = data.split_nodes(random_state=15)

for backend in ['th', 'dgl', 'pyg', 'tf']:
    gg.set_backend(backend)
    for device in ['cpu', 'cuda', 'gpu']:
        for name, m in gg.gallery.nodeclas.models():
            if name in ['LGCN', 'GraphMLP', 'PDN', 'ClusterGCN']:
                continue
            print(backend, device, name)
            trainer = m(device=device)
            trainer.setup_graph(graph, feat_transform=None)
            trainer.build()
            trainer.fit(splits.train_nodes,
                        splits.val_nodes,
                        verbose=0,
                        epochs=2)
示例#6
0
import graphgallery as gg
from graphgallery import functional as gf
from graphgallery.datasets import NPZDataset

gg.set_backend("th")

data = NPZDataset('cora',
                  root="~/GraphData/datasets/",
                  verbose=False,
                  transform="standardize")

graph = data.graph
splits = data.split_nodes(random_state=15)

################### Surrogate model ############################
trainer = gg.gallery.nodeclas.SGC(seed=1000).make_data(graph, K=2).build()
his = trainer.fit(splits.train_nodes, splits.val_nodes, verbose=2, epochs=100)

################### Attacker model ############################
target = 1
attacker = gg.attack.targeted.SGA(graph, seed=123).process(trainer)
attacker.attack(target)

################### Victim model ############################
# Before attack
trainer = gg.gallery.nodeclas.GCN(seed=123).make_data(graph).build()
his = trainer.fit(splits.train_nodes, splits.val_nodes, verbose=2, epochs=100)
original_predict = trainer.predict(target, transform="softmax")

# After attack
trainer = gg.gallery.nodeclas.GCN(seed=123).make_data(attacker.g).build()