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)