import matplotlib.pyplot as plt
if torch.cuda.is_available():
torch.cuda.manual_seed_all(1)
else:
torch.manual_seed(1)
# 1. dataset
dataset = YooChooseBinaryDataset(root=pyg_yoochoose_10k()).shuffle()
train_ds, val_ds, test_ds = dataset[:8000], dataset[8000:9000], dataset[9000:]
train_dl = PyGDataLoader(train_ds, batch_size=64, shuffle=True)
val_dl = PyGDataLoader(val_ds, batch_size=64)
test_dl = PyGDataLoader(test_ds, batch_size=64)
train_db = DataBunch(train_dl, val_dl)
# 2. mode and optimizer
class Model(nn.Module):
def __init__(self, feature_dim, class_num, embed_dim=64, gcn_dims=(32, 32), dense_dim=64):
super().__init__()
self.embedding = torch.nn.Embedding(num_embeddings=feature_dim, embedding_dim=embed_dim)
self.gcns = nn.ModuleList()
in_dim = embed_dim
for dim in gcn_dims:
self.gcns.append(GCNConv(in_dim, dim))
in_dim = dim
self.graph_pooling = TopKPooling(gcn_dims[-1], ratio=0.8)
self.dense = nn.Linear(gcn_dims[-1], dense_dim)
self.out = nn.Linear(dense_dim, class_num)
from bijou.learner import Learner
from bijou.metrics import masked_cross_entropy, masked_accuracy
from bijou.datasets import cora
import matplotlib.pyplot as plt
if torch.cuda.is_available():
torch.cuda.manual_seed_all(1)
else:
torch.manual_seed(1)
# 1. dataset
dataset = Planetoid(root=cora(), name='Cora')
train_data = PyGDataWrapper(dataset[0], 'train')
val_data = PyGDataWrapper(dataset[0], 'val')
test_data = PyGDataWrapper(dataset[0], 'test')
data = DataBunch(train_data, val_data)
# 2. model and optimizer
class Model(nn.Module):
def __init__(self, feature_num, class_num):
super().__init__()
self.conv1 = GCNConv(feature_num, 16)
self.conv2 = GCNConv(16, class_num)
def forward(self, data):
x, edge_index = data.x, data.edge_index
x = self.conv1(x, edge_index)
x = F.relu(x)
x = self.conv2(x, edge_index)
outputs = F.relu(x)
from torch import optim
from bijou.learner import Learner
from bijou.data import Dataset, DataLoader, DataBunch
from bijou.metrics import accuracy
from bijou.callbacks import EarlyStopping
from bijou.datasets import mnist
import matplotlib.pyplot as plt
x_train, y_train, x_valid, y_valid, x_test, y_test = mnist()
train_ds, valid_ds, test_ds = Dataset(x_train, y_train), Dataset(
x_valid, y_valid), Dataset(x_test, y_test)
bs = 128
train_dl = DataLoader(train_ds, batch_size=bs, shuffle=True)
valid_dl = DataLoader(valid_ds, batch_size=bs)
test_dl = DataLoader(test_ds, batch_size=bs)
data = DataBunch(train_dl, valid_dl)
in_dim = data.train_ds.x.shape[1]
h_dim = 128
model = nn.Sequential(nn.Linear(in_dim, h_dim), nn.ReLU(),
nn.Linear(h_dim, 10))
opt = optim.SGD(model.parameters(), lr=1.5)
loss_func = F.cross_entropy
learner = Learner(model,
opt,
loss_func,
data,
metrics=[accuracy],
callbacks=EarlyStopping(patience=3))
import matplotlib.pyplot as plt
if torch.cuda.is_available():
torch.cuda.manual_seed_all(1)
else:
torch.manual_seed(1)
# 1. dataset
dataset = Planetoid(root=pyg_cora(), name='Cora')
g = dataset[0]
train_dl = GraphLoader(g, labels=g.y, mask=g.train_mask)
val_dl = GraphLoader(g, labels=g.y, mask=g.val_mask)
test_dl = GraphLoader(g, labels=g.y, mask=g.test_mask)
# train_dl, val_dl, test_dl = GraphLoader.loaders(g, labels=g.y, masks=[g.train_mask, g.val_mask, g.test_mask])
data = DataBunch(train_dl, train_dl)
# 2. model and optimizer
class Model(nn.Module):
def __init__(self, feature_num, class_num):
super().__init__()
self.conv1 = GCNConv(feature_num, 16)
self.conv2 = GCNConv(16, class_num)
def forward(self, data):
x, edge_index = data.x, data.edge_index
x = self.conv1(x, edge_index)
x = F.relu(x)
x = self.conv2(x, edge_index)
outputs = F.relu(x)
