def main(args):
if paddle.distributed.get_world_size() > 1:
paddle.distributed.init_parallel_env()
graph = load(args.dataset)
model = SkipGramModel(
graph.num_nodes,
args.embed_size,
args.neg_num,
sparse=not args.use_cuda)
model = paddle.DataParallel(model)
optim = Adam(
learning_rate=args.learning_rate,
parameters=model.parameters(),
weight_decay=args.weight_decay)
train_ds = ShardedDataset(graph.nodes)
collate_fn = BatchRandWalk(graph, args.walk_len, args.win_size,
args.neg_num, args.neg_sample_type)
data_loader = Dataloader(
train_ds,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.sample_workers,
collate_fn=collate_fn)
for epoch in tqdm.tqdm(range(args.epoch)):
train_loss = train(model, data_loader, optim)
log.info("Runing epoch:%s\t train_loss:%.6f", epoch, train_loss)
def get_data_loader(self,
batch_size,
num_workers=4,
shuffle=False,
collate_fn=None):
"""
It returns an batch iterator which yields a batch of data. Firstly, a sub-list of
`data` of size ``batch_size`` will be draw from the ``data_list``, then
the function ``collate_fn`` will be applied to the sub-list to create a batch and
yield back. This process is accelerated by multiprocess.
Args:
batch_size(int): the batch_size of the batch data of each yield.
num_workers(int): the number of workers used to generate batch data. Required by
multiprocess.
shuffle(bool): whether to shuffle the order of the ``data_list``.
collate_fn(function): used to convert the sub-list of ``data_list`` to the
aggregated batch data.
Yields:
the batch data processed by ``collate_fn``.
"""
return Dataloader(self,
batch_size=batch_size,
num_workers=num_workers,
shuffle=shuffle,
collate_fn=collate_fn)
def mp_pool_map(list_input, func, num_workers):
"""list_output = [func(input) for input in list_input]"""
class _CollateFn(object):
def __init__(self, func):
self.func = func
def __call__(self, data_list):
new_data_list = []
for data in data_list:
index, input = data
new_data_list.append((index, self.func(input)))
return new_data_list
# add index
list_new_input = [(index, x) for index, x in enumerate(list_input)]
data_gen = Dataloader(list_new_input,
batch_size=8,
num_workers=num_workers,
shuffle=False,
collate_fn=_CollateFn(func))
list_output = []
for sub_outputs in data_gen:
list_output += sub_outputs
list_output = sorted(list_output, key=lambda x: x[0])
# remove index
list_output = [x[1] for x in list_output]
return list_output
def main(args):
if not args.use_cuda:
paddle.set_device("cpu")
if paddle.distributed.get_world_size() > 1:
paddle.distributed.init_parallel_env()
graph = load(args.dataset)
model = SkipGramModel(graph.num_nodes,
args.embed_size,
args.neg_num,
sparse=not args.use_cuda)
model = paddle.DataParallel(model)
train_steps = int(graph.num_nodes / args.batch_size) * args.epoch
scheduler = paddle.optimizer.lr.PolynomialDecay(
learning_rate=args.learning_rate,
decay_steps=train_steps,
end_lr=0.0001)
optim = Adam(learning_rate=scheduler, parameters=model.parameters())
train_ds = ShardedDataset(graph.nodes)
collate_fn = BatchRandWalk(graph, args.walk_len, args.win_size,
args.neg_num, args.neg_sample_type)
data_loader = Dataloader(train_ds,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.sample_workers,
collate_fn=collate_fn)
for epoch in tqdm.tqdm(range(args.epoch)):
train_loss = train(model, data_loader, optim)
log.info("Runing epoch:%s\t train_loss:%.6f", epoch, train_loss)
paddle.save(model.state_dict(), "model.pdparams")
def infer(config, output_path):
model = getattr(M, config.model_type)(config)
log.info("infer model from %s" % config.infer_from)
model.set_state_dict(paddle.load(config.infer_from))
log.info("loading data")
ds = getattr(DS, config.dataset_type)(config)
split_idx = ds.get_idx_split()
test_ds = DS.Subset(ds, split_idx['test'], mode='test')
log.info("Test exapmles: %s" % len(test_ds))
test_loader = Dataloader(test_ds,
batch_size=config.valid_batch_size,
shuffle=False,
num_workers=1,
collate_fn=DS.CollateFn(config))
### automatic evaluator. takes dataset name as input
evaluator = PCQM4MEvaluator()
# ---------------- test ----------------------- #
log.info("testing ...")
pred_dict = evaluate(model, test_loader)
test_output_path = os.path.join(config.output_dir, config.task_name)
make_dir(test_output_path)
test_output_file = os.path.join(test_output_path, "test_pred.npz")
log.info("saving test result to %s" % test_output_file)
np.savez_compressed(test_output_file,
pred_dict['y_pred'].astype(np.float32))
def test_InferDataset():
config_file = "../../../config.yaml"
ip_list_file = "../../../ip_list.txt"
config = prepare_config(config_file)
ds = InferDataset(config, ip_list_file)
loader = Dataloader(ds, batch_size=1, num_workers=1)
for data in loader:
print(data[0])
break
def main(args):
paddle.set_device("cpu")
paddle.enable_static()
fleet.init()
fake_num_nodes = 1
py_reader, loss = StaticSkipGramModel(
fake_num_nodes,
args.neg_num,
args.embed_size,
sparse_embedding=True,
shared_embedding=args.shared_embedding)
optimizer = F.optimizer.Adam(args.learning_rate, lazy_mode=True)
dist_strategy = fleet.DistributedStrategy()
dist_strategy.a_sync = True
optimizer = fleet.distributed_optimizer(optimizer, dist_strategy)
optimizer.minimize(loss)
# init and run server or worker
if fleet.is_server():
fleet.init_server()
fleet.run_server()
if fleet.is_worker():
place = paddle.CPUPlace()
exe = paddle.static.Executor(place)
exe.run(paddle.static.default_startup_program())
fleet.init_worker()
graph = build_graph(args)
# bind gen
train_ds = ShardedDataset(graph.nodes, args.epoch)
collate_fn = BatchRandWalk(graph, args.walk_len, args.win_size,
args.neg_num, args.neg_sample_type)
data_loader = Dataloader(train_ds,
batch_size=args.cpu_batch_size,
shuffle=True,
num_workers=args.sample_workers,
collate_fn=collate_fn)
py_reader.set_batch_generator(lambda: data_loader)
train_loss = train(exe, paddle.static.default_main_program(),
py_reader, loss)
fleet.stop_worker()
if fleet.is_first_worker():
fleet.save_persistables(exe, "./model",
paddle.static.default_main_program())
def main(args):
paddle.set_device("cpu")
paddle.enable_static()
role = role_maker.PaddleCloudRoleMaker()
fleet.init(role)
if args.num_nodes is None:
num_nodes = load(args.dataset).num_nodes
else:
num_nodes = args.num_nodes
loss = StaticSkipGramModel(
num_nodes, args.neg_num, args.embed_size, sparse=True)
optimizer = F.optimizer.Adam(args.learning_rate, lazy_mode=True)
dist_strategy = fleet.DistributedStrategy()
dist_strategy.a_sync = True
optimizer = fleet.distributed_optimizer(optimizer, dist_strategy)
optimizer.minimize(loss)
# init and run server or worker
if fleet.is_server():
fleet.init_server()
fleet.run_server()
if fleet.is_worker():
place = paddle.CPUPlace()
exe = paddle.static.Executor(place)
exe.run(paddle.static.default_startup_program())
fleet.init_worker()
graph = load(args.dataset)
# bind gen
train_ds = ShardedDataset(graph.nodes)
collate_fn = BatchRandWalk(graph, args.walk_len, args.win_size,
args.neg_num, args.neg_sample_type)
data_loader = Dataloader(
train_ds,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.sample_workers,
collate_fn=collate_fn)
for epoch in range(args.epoch):
train_loss = train(exe,
paddle.static.default_main_program(),
data_loader, loss)
log.info("Runing epoch:%s\t train_loss:%.6f", epoch, train_loss)
fleet.stop_worker()
def main(args):
paddle.enable_static()
paddle.set_device('gpu:%d' % paddle.distributed.ParallelEnv().dev_id)
fleet.init(is_collective=True)
graph = load(args.dataset)
loss = StaticSkipGramModel(graph.num_nodes,
args.neg_num,
args.embed_size,
num_emb_part=args.num_emb_part,
shared_embedding=args.shared_embedding)
optimizer = F.optimizer.Adam(args.learning_rate)
dist_strategy = fleet.DistributedStrategy()
dist_strategy.sharding = True
dist_strategy.sharding_configs = {
"segment_anchors": None,
"sharding_segment_strategy": "segment_broadcast_MB",
"segment_broadcast_MB": 32,
"sharding_degree": int(paddle.distributed.get_world_size()),
}
optimizer = fleet.distributed_optimizer(optimizer, dist_strategy)
optimizer.minimize(loss)
place = paddle.CUDAPlace(paddle.distributed.ParallelEnv().dev_id)
exe = paddle.static.Executor(place)
exe.run(paddle.static.default_startup_program())
# bind gen
train_ds = ShardedDataset(graph.nodes)
collate_fn = BatchRandWalk(graph, args.walk_len, args.win_size,
args.neg_num, args.neg_sample_type)
data_loader = Dataloader(train_ds,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.sample_workers,
collate_fn=collate_fn)
for epoch in range(args.epoch):
train_loss = train(exe, paddle.static.default_main_program(),
data_loader, loss)
log.info("Runing epoch:%s\t train_loss:%.6f", epoch, train_loss)
fleet.stop_worker()
if fleet.is_first_worker():
fleet.save_persistables(exe, "./model",
paddle.static.default_main_program())
def get_data_loader(self, batch_size, num_workers=1,
shuffle=False, collate_fn=None):
"""Get dataloader.
Args:
batch_size (int): number of data items in a batch.
num_workers (int): number of parallel workers.
shuffle (int): whether to shuffle yield data.
collate_fn: callable function that processes batch data to a list of paddle tensor.
"""
return Dataloader(
self,
batch_size=batch_size,
num_workers=num_workers,
shuffle=shuffle,
collate_fn=collate_fn)
def test_PairDataset():
config_file = "../../../config.yaml"
ip_list_file = "../../../ip_list.txt"
config = prepare_config(config_file)
ds = TrainPairDataset(config, ip_list_file)
loader = Dataloader(ds,
batch_size=4,
num_workers=1,
stream_shuffle_size=100,
collate_fn=CollateFn())
pairs = []
start = time.time()
for batch_data in loader:
pairs.extend(batch_data)
print(batch_data)
time.sleep(10)
print("total time: %s" % (time.time() - start))
def main(args):
if not args.use_cuda:
paddle.set_device("cpu")
if paddle.distributed.get_world_size() > 1:
paddle.distributed.init_parallel_env()
if args.edge_file:
graph = load_from_file(args.edge_file)
else:
graph = load(args.dataset)
edges = np.load("./edges.npy")
edges = np.concatenate([edges, edges[:, [1, 0]]])
graph = pgl.Graph(edges)
model = SkipGramModel(graph.num_nodes,
args.embed_size,
args.neg_num,
sparse=not args.use_cuda)
model = paddle.DataParallel(model)
train_ds = ShardedDataset(graph.nodes, repeat=args.epoch)
train_steps = int(len(train_ds) // args.batch_size)
log.info("train_steps: %s" % train_steps)
scheduler = paddle.optimizer.lr.PolynomialDecay(
learning_rate=args.learning_rate,
decay_steps=train_steps,
end_lr=0.0001)
optim = Adam(learning_rate=scheduler, parameters=model.parameters())
collate_fn = BatchRandWalk(graph, args.walk_len, args.win_size,
args.neg_num, args.neg_sample_type)
data_loader = Dataloader(train_ds,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.sample_workers,
collate_fn=collate_fn)
train_loss = train(model, data_loader, optim)
paddle.save(model.state_dict(), "model.pdparams")
def main(config, ip_list_file):
ds = TrainPairDataset(config, ip_list_file)
loader = Dataloader(
ds,
batch_size=config.batch_pair_size,
num_workers=config.num_workers,
stream_shuffle_size=config.pair_stream_shuffle_size,
collate_fn=CollateFn())
model = SkipGramModel(config)
if config.warm_start_from:
log.info("warm start from %s" % config.warm_start_from)
model.set_state_dict(paddle.load(config.warm_start_from))
optim = Adam(
learning_rate=config.lr,
parameters=model.parameters(),
lazy_mode=config.lazy_mode)
log.info("starting training...")
train(config, model, loader, optim)
def main(args):
"""
Args:
-ddi: drug drug synergy file.
-rna: cell line gene expression file.
-lincs: gene embeddings.
-dropout: dropout rate for transformer blocks.
-epochs: training epochs.
-batch_size
-lr: learning rate.
"""
#paddle.set_device('cpu')
ddi = pd.read_csv(args.ddi)
rna = pd.read_csv(args.rna, index_col=0)
lincs = pd.read_csv(args.lincs, index_col=0, header=None).values
lincs = paddle.to_tensor(lincs, 'float32')
##############independent validation############
#5-fold cross validation
"""NUM_CROSS = 5
ddi_shuffle = shuffle(ddi)
data_size = len(ddi)
fold_num = int(data_size / NUM_CROSS)
for fold in range(NUM_CROSS):
ddi_test = ddi_shuffle.iloc[fold*fold_num:fold_num * (fold + 1), :]
ddi_train_before = ddi_shuffle.iloc[:fold*fold_num, :]
ddi_train_after = ddi_shuffle.iloc[fold_num * (fold + 1):, :]
ddi_train = pd.concat([ddi_train_before, ddi_train_after])"""
ddi_train = ddi.copy()
train_cell = join_cell(ddi_train, rna)
bt_tr = DDsData(ddi_train['drug1'].values, ddi_train['drug2'].values,
train_cell, ddi_train['label'].values)
"""test_cell = join_cell(ddi_test, rna)
#test_pta, test_ptb = join_pert(ddi_test, drugs_pert)
bt_test = DDsData(ddi_test['drug1'].values,
ddi_test['drug2'].values,
test_cell,
ddi_test['label'].values)"""
loader_tr = Dataloader(bt_tr,
batch_size=args.batch_size,
num_workers=4,
collate_fn=collate)
#loader_test = Dataloader(bt_test, batch_size=args.batch_size, num_workers=4, collate_fn=collate)
#loader_val = Dataloader(bt_val, batch_size=args.batch_size, num_workers=1, collate_fn=collate)
model = TSNet(num_drug_feat=78,
num_L_feat=978,
num_cell_feat=rna.shape[1],
num_drug_out=128,
coarsed_heads=4,
fined_heads=4,
coarse_hidd=64,
fine_hidd=64,
dropout=args.dropout)
opt = paddle.optimizer.Adam(learning_rate=args.lr,
parameters=model.parameters())
loss_fn = paddle.nn.CrossEntropyLoss()
for e in range(args.epochs):
train_loss = train(model, loader_tr, lincs, loss_fn, opt)
print('Epoch {}---training loss:{}'.format(e, train_loss))
t_auc, test_prauc, test_loss, acc, bacc, prec, tpr, kappa = test_auc(
model, loader_test, lincs, loss_fn)
print(
'---Testing loss:{:.4f}, AUC:{:.4f}, PRAUC:{:.4f}, ACC:{:.4f}, BACC:{:.4f}, PREC:{:.4f}, TPR:{:.4f}, KAPPA:{:.4f}'
.format(test_loss, t_auc, test_prauc, acc, bacc, prec, tpr, kappa))
def main(config):
if dist.get_world_size() > 1:
dist.init_parallel_env()
if not config.use_cuda:
paddle.set_device("cpu")
model = getattr(M, config.model_type)(config)
if config.warm_start_from:
log.info("warm start from %s" % config.warm_start_from)
model.set_state_dict(paddle.load(config.warm_start_from))
model = paddle.DataParallel(model)
num_params = sum(p.numel() for p in model.parameters())
log.info("total Parameters: %s" % num_params)
if config.lr_mode == "step_decay":
scheduler = paddle.optimizer.lr.StepDecay(learning_rate=config.lr,
step_size=config.step_size,
gamma=config.gamma)
elif config.lr_mode == "multistep":
scheduler = paddle.optimizer.lr.MultiStepDecay(
learning_rate=config.lr,
milestones=config.milestones,
gamma=config.gamma)
elif config.lr_mode == "piecewise":
log.info(['boundery: ', config.boundery])
log.info(['lr_value: ', config.lr_value])
for i in config.lr_value:
if not isinstance(i, float):
raise "lr_value %s is not float number" % i
scheduler = paddle.optimizer.lr.PiecewiseDecay(config.boundery,
config.lr_value)
elif config.lr_mode == "Reduce":
scheduler = paddle.optimizer.lr.ReduceOnPlateau(
learning_rate=config.lr,
factor=config.factor,
patience=config.patience)
else:
scheduler = config.lr
optimizer = getattr(paddle.optimizer,
config.optim)(learning_rate=scheduler,
parameters=model.parameters())
log.info("loading data")
ds = getattr(DS, config.dataset_type)(config)
if config.split_mode == "cross1":
split_idx = ds.get_cross_idx_split()
train_ds = DS.Subset(ds, split_idx['cross_train_1'], mode='train')
valid_ds = DS.Subset(ds, split_idx['cross_valid_1'], mode='valid')
left_valid_ds = DS.Subset(ds,
split_idx['valid_left_1percent'],
mode='valid')
test_ds = DS.Subset(ds, split_idx['test'], mode='test')
elif config.split_mode == "cross1_few":
split_idx = ds.get_cross_idx_split()
train_ds = DS.Subset(ds,
split_idx['cross_train_1'][:10000],
mode='train')
valid_ds = DS.Subset(ds,
split_idx['cross_train_1'][10000:11000],
mode='valid')
left_valid_ds = DS.Subset(ds,
split_idx['cross_train_1'][10000:11000],
mode='valid')
test_ds = DS.Subset(ds,
split_idx['cross_train_1'][11000:12000],
mode='test')
elif config.split_mode == "cross2":
split_idx = ds.get_cross_idx_split()
train_ds = DS.Subset(ds, split_idx['cross_train_2'], mode='train')
valid_ds = DS.Subset(ds, split_idx['cross_valid_2'], mode='valid')
left_valid_ds = DS.Subset(ds,
split_idx['valid_left_1percent'],
mode='valid')
test_ds = DS.Subset(ds, split_idx['test'], mode='test')
else:
split_idx = ds.get_idx_split()
train_ds = DS.Subset(ds, split_idx['train'], mode='train')
valid_ds = DS.Subset(ds, split_idx['valid'], mode='valid')
left_valid_ds = DS.Subset(ds, split_idx['valid'], mode='valid')
test_ds = DS.Subset(ds, split_idx['test'], mode='test')
log.info("Train exapmles: %s" % len(train_ds))
log.info("Valid exapmles: %s" % len(valid_ds))
log.info("Test exapmles: %s" % len(test_ds))
log.info("Left Valid exapmles: %s" % len(left_valid_ds))
train_loader = Dataloader(train_ds,
batch_size=config.batch_size,
shuffle=True,
num_workers=config.num_workers,
collate_fn=DS.CollateFn(config),
drop_last=True)
valid_loader = Dataloader(valid_ds,
batch_size=config.valid_batch_size,
shuffle=False,
num_workers=1,
collate_fn=DS.CollateFn(config))
left_valid_loader = Dataloader(left_valid_ds,
batch_size=config.valid_batch_size,
shuffle=False,
num_workers=1,
collate_fn=DS.CollateFn(config))
test_loader = Dataloader(test_ds,
batch_size=config.valid_batch_size,
shuffle=False,
num_workers=1,
collate_fn=DS.CollateFn(config))
if config.split_mode is not None:
valids = {'valid': valid_loader, 'left': left_valid_loader}
else:
valids = {'valid': valid_loader}
if config.pretrain_tasks:
pretrain_train_and_eval(model, config, train_loader, valids,
test_loader, optimizer, scheduler)
else:
train_and_eval(model, config, train_loader, valids, test_loader,
optimizer, scheduler)
list, zip(*batch))
a2a_g = pgl.Graph.batch(a2a_gs).tensor()
b2a_g = pgl.BiGraph.batch(b2a_gs).tensor()
b2b_gl = [
pgl.Graph.batch([g[i] for g in b2b_gs_l]).tensor()
for i in range(len(b2b_gs_l[0]))
]
feats = paddle.concat(
[paddle.to_tensor(f, dtype='float32') for f in feats])
types = paddle.concat([paddle.to_tensor(t) for t in types])
counts = paddle.stack([paddle.to_tensor(c) for c in counts], axis=1)
labels = paddle.to_tensor(np.array(labels), dtype='float32')
return a2a_g, b2a_g, b2b_gl, feats, types, counts, labels
if __name__ == "__main__":
complex_data = ComplexDataset("./data/", "pdbbind2016_test", 5, 6)
loader = Dataloader(complex_data,
batch_size=32,
shuffle=False,
num_workers=1,
collate_fn=collate_fn)
cc = 0
for batch in loader:
a2a_g, b2a_g, b2b_gl, feats, types, counts, labels = batch
print(labels)
cc += 1
if cc == 2:
break
def main():
# Training settings
parser = argparse.ArgumentParser(
description='GNN baselines on pcqm4m with PGL')
parser.add_argument('--use_cuda', action='store_true')
parser.add_argument('--device',
type=int,
default=0,
help='which gpu to use if any (default: 0)')
parser.add_argument(
'--gnn',
type=str,
default='gin-virtual',
help=
'GNN gin, gin-virtual, or gcn, or gcn-virtual (default: gin-virtual)')
parser.add_argument(
'--graph_pooling',
type=str,
default='sum',
help='graph pooling strategy mean or sum (default: sum)')
parser.add_argument('--drop_ratio',
type=float,
default=0,
help='dropout ratio (default: 0)')
parser.add_argument(
'--num_layers',
type=int,
default=5,
help='number of GNN message passing layers (default: 5)')
parser.add_argument(
'--emb_dim',
type=int,
default=600,
help='dimensionality of hidden units in GNNs (default: 600)')
parser.add_argument('--train_subset', action='store_true')
parser.add_argument('--batch_size',
type=int,
default=256,
help='input batch size for training (default: 256)')
parser.add_argument('--epochs',
type=int,
default=100,
help='number of epochs to train (default: 100)')
parser.add_argument('--num_workers',
type=int,
default=1,
help='number of workers (default: 1)')
parser.add_argument('--log_dir',
type=str,
default="",
help='tensorboard log directory')
parser.add_argument('--checkpoint_dir',
type=str,
default='',
help='directory to save checkpoint')
parser.add_argument('--save_test_dir',
type=str,
default='',
help='directory to save test submission file')
args = parser.parse_args()
print(args)
random.seed(42)
np.random.seed(42)
paddle.seed(42)
if not args.use_cuda:
paddle.set_device("cpu")
### automatic dataloading and splitting
class Config():
def __init__(self):
self.base_data_path = "./dataset"
config = Config()
ds = MolDataset(config)
split_idx = ds.get_idx_split()
test_ds = Subset(ds, split_idx['test'])
print("Test exapmles: ", len(test_ds))
### automatic evaluator. takes dataset name as input
evaluator = PCQM4MEvaluator()
test_loader = Dataloader(test_ds,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers,
collate_fn=CollateFn())
shared_params = {
'num_layers': args.num_layers,
'emb_dim': args.emb_dim,
'drop_ratio': args.drop_ratio,
'graph_pooling': args.graph_pooling
}
if args.gnn == 'gin':
model = GNN(gnn_type='gin', virtual_node=False, **shared_params)
elif args.gnn == 'gin-virtual':
model = GNN(gnn_type='gin', virtual_node=True, **shared_params)
elif args.gnn == 'gcn':
model = GNN(gnn_type='gcn', virtual_node=False, **shared_params)
elif args.gnn == 'gcn-virtual':
model = GNN(gnn_type='gcn', virtual_node=True, **shared_params)
else:
raise ValueError('Invalid GNN type')
num_params = sum(p.numel() for p in model.parameters())
print(f'#Params: {num_params}')
checkpoint_path = os.path.join(args.checkpoint_dir, 'checkpoint.pdparams')
if not os.path.exists(checkpoint_path):
raise RuntimeError(f'Checkpoint file not found at {checkpoint_path}')
model.set_state_dict(paddle.load(checkpoint_path))
print('Predicting on test data...')
y_pred = test(model, test_loader)
print('Saving test submission file...')
evaluator.save_test_submission({'y_pred': y_pred}, args.save_test_dir)
def main(config):
if dist.get_world_size() > 1:
dist.init_parallel_env()
if dist.get_rank() == 0:
timestamp = datetime.now().strftime("%Hh%Mm%Ss")
log_path = os.path.join(config.log_dir,
"tensorboard_log_%s" % timestamp)
writer = SummaryWriter(log_path)
log.info("loading data")
raw_dataset = GraphPropPredDataset(name=config.dataset_name)
config.num_class = raw_dataset.num_tasks
config.eval_metric = raw_dataset.eval_metric
config.task_type = raw_dataset.task_type
mol_dataset = MolDataset(config,
raw_dataset,
transform=make_multihop_edges)
splitted_index = raw_dataset.get_idx_split()
train_ds = Subset(mol_dataset, splitted_index['train'], mode='train')
valid_ds = Subset(mol_dataset, splitted_index['valid'], mode="valid")
test_ds = Subset(mol_dataset, splitted_index['test'], mode="test")
log.info("Train Examples: %s" % len(train_ds))
log.info("Val Examples: %s" % len(valid_ds))
log.info("Test Examples: %s" % len(test_ds))
fn = CollateFn(config)
train_loader = Dataloader(train_ds,
batch_size=config.batch_size,
shuffle=True,
num_workers=config.num_workers,
collate_fn=fn)
valid_loader = Dataloader(valid_ds,
batch_size=config.batch_size,
num_workers=config.num_workers,
collate_fn=fn)
test_loader = Dataloader(test_ds,
batch_size=config.batch_size,
num_workers=config.num_workers,
collate_fn=fn)
model = ClassifierNetwork(config.hidden_size, config.out_dim,
config.num_layers, config.dropout_prob,
config.virt_node, config.K, config.conv_type,
config.appnp_hop, config.alpha)
model = paddle.DataParallel(model)
optim = Adam(learning_rate=config.lr, parameters=model.parameters())
criterion = nn.loss.BCEWithLogitsLoss()
evaluator = Evaluator(config.dataset_name)
best_valid = 0
global_step = 0
for epoch in range(1, config.epochs + 1):
model.train()
for idx, batch_data in enumerate(train_loader):
g, mh_graphs, labels, unmask = batch_data
g = g.tensor()
multihop_graphs = []
for item in mh_graphs:
multihop_graphs.append(item.tensor())
g.multi_hop_graphs = multihop_graphs
labels = paddle.to_tensor(labels)
unmask = paddle.to_tensor(unmask)
pred = model(g)
pred = paddle.masked_select(pred, unmask)
labels = paddle.masked_select(labels, unmask)
train_loss = criterion(pred, labels)
train_loss.backward()
optim.step()
optim.clear_grad()
if global_step % 80 == 0:
message = "train: epoch %d | step %d | " % (epoch, global_step)
message += "loss %.6f" % (train_loss.numpy())
log.info(message)
if dist.get_rank() == 0:
writer.add_scalar("loss", train_loss.numpy(), global_step)
global_step += 1
valid_result = evaluate(model, valid_loader, criterion, evaluator)
message = "valid: epoch %d | step %d | " % (epoch, global_step)
for key, value in valid_result.items():
message += " | %s %.6f" % (key, value)
if dist.get_rank() == 0:
writer.add_scalar("valid_%s" % key, value, global_step)
log.info(message)
test_result = evaluate(model, test_loader, criterion, evaluator)
message = "test: epoch %d | step %d | " % (epoch, global_step)
for key, value in test_result.items():
message += " | %s %.6f" % (key, value)
if dist.get_rank() == 0:
writer.add_scalar("test_%s" % key, value, global_step)
log.info(message)
if best_valid < valid_result[config.metrics]:
best_valid = valid_result[config.metrics]
best_valid_result = valid_result
best_test_result = test_result
message = "best result: epoch %d | " % (epoch)
message += "valid %s: %.6f | " % (config.metrics,
best_valid_result[config.metrics])
message += "test %s: %.6f | " % (config.metrics,
best_test_result[config.metrics])
log.info(message)
message = "final eval best result:%.6f" % best_valid_result[config.metrics]
log.info(message)
message = "final test best result:%.6f" % best_test_result[config.metrics]
log.info(message)
def main(args):
ds = GINDataset(args.data_path,
args.dataset_name,
self_loop=not args.train_eps,
degree_as_nlabel=True)
args.feat_size = ds.dim_nfeats
train_ds, test_ds = fold10_split(ds,
fold_idx=args.fold_idx,
seed=args.seed)
train_loader = Dataloader(train_ds,
batch_size=args.batch_size,
shuffle=True,
num_workers=1,
collate_fn=collate_fn)
test_loader = Dataloader(test_ds,
batch_size=args.batch_size,
shuffle=False,
num_workers=1,
collate_fn=collate_fn)
model = GINModel(args, ds.gclasses)
epoch_step = len(train_loader)
boundaries = [
i for i in range(50 * epoch_step, args.epochs *
epoch_step, epoch_step * 50)
]
values = [args.lr * 0.5**i for i in range(0, len(boundaries) + 1)]
scheduler = paddle.optimizer.lr.PiecewiseDecay(boundaries=boundaries,
values=values,
verbose=False)
optim = Adam(learning_rate=scheduler, parameters=model.parameters())
criterion = nn.loss.CrossEntropyLoss()
global_step = 0
best_acc = 0.0
for epoch in range(1, args.epochs + 1):
model.train()
for idx, batch_data in enumerate(train_loader):
graphs, labels = batch_data
g = pgl.Graph.batch(graphs).tensor()
labels = paddle.to_tensor(labels)
pred = model(g)
train_loss = criterion(pred, labels)
train_loss.backward()
train_acc = paddle.metric.accuracy(input=pred, label=labels, k=1)
optim.step()
optim.clear_grad()
scheduler.step()
global_step += 1
if global_step % 10 == 0:
message = "train: epoch %d | step %d | " % (epoch, global_step)
message += "loss %.6f | acc %.4f" % (train_loss, train_acc)
log.info(message)
result = evaluate(model, test_loader, criterion)
message = "eval: epoch %d | step %d | " % (epoch, global_step)
for key, value in result.items():
message += " | %s %.6f" % (key, value)
log.info(message)
if best_acc < result['acc']:
best_acc = result['acc']
log.info("best evaluating accuracy: %.6f" % best_acc)
def main(args):
paddle.set_device("cpu")
paddle.enable_static()
fleet.init()
if args.num_nodes is None:
num_nodes = load(args.dataset).num_nodes
else:
num_nodes = args.num_nodes
loss = StaticSkipGramModel(num_nodes,
args.neg_num,
args.embed_size,
sparse=True)
optimizer = F.optimizer.Adam(args.learning_rate, lazy_mode=True)
dist_strategy = fleet.DistributedStrategy()
dist_strategy.a_sync = True
optimizer = fleet.distributed_optimizer(optimizer, dist_strategy)
optimizer.minimize(loss)
# init and run server or worker
if fleet.is_server():
fleet.init_server()
fleet.run_server()
if fleet.is_worker():
place = paddle.CPUPlace()
exe = paddle.static.Executor(place)
exe.run(paddle.static.default_startup_program())
fleet.init_worker()
graph = load(args.dataset)
# bind gen
train_ds = ShardedDataset(graph.nodes)
collate_fn = BatchRandWalk(graph, args.walk_len, args.win_size,
args.neg_num, args.neg_sample_type)
data_loader = Dataloader(train_ds,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.sample_workers,
collate_fn=collate_fn)
cpu_num = int(os.environ.get('CPU_NUM', 1))
if int(cpu_num) > 1:
parallel_places = [paddle.CPUPlace()] * cpu_num
exec_strategy = paddle.static.ExecutionStrategy()
exec_strategy.num_threads = int(cpu_num)
build_strategy = paddle.static.BuildStrategy()
build_strategy.reduce_strategy = paddle.static.BuildStrategy.ReduceStrategy.Reduce
compiled_prog = paddle.static.CompiledProgram(
paddle.static.default_main_program()).with_data_parallel(
loss_name=loss.name,
places=parallel_places,
build_strategy=build_strategy,
exec_strategy=exec_strategy)
else:
compiled_prog = paddle.static.default_main_program()
for epoch in range(args.epoch):
train_loss = train(exe, compiled_prog, data_loader, loss)
log.info("Runing epoch:%s\t train_loss:%.6f", epoch, train_loss)
fleet.stop_worker()
if fleet.is_first_worker():
fleet.save_persistables(exe, "./model",
paddle.static.default_main_program())
args.label_data_path,
args.use_cache,
)
valid_dataset = MyDataset(
valid_chain_list,
args.n_channels,
args.pad_len,
args.protein_chain_graphs,
args.cmap_thresh,
args.label_data_path,
args.use_cache,
)
train_loader = Dataloader(
train_dataset,
batch_size=args.batch_size,
shuffle=True,
collate_fn=train_dataset.collate_fn,
)
valid_loader = Dataloader(valid_dataset,
batch_size=args.batch_size,
collate_fn=valid_dataset.collate_fn)
args.n_labels = train_dataset.n_labels
model = DeepFRI(args)
task_name = os.path.split(args.label_data_path)[-1]
task_name = os.path.splitext(task_name)[0]
args.task = task_name
time_stamp = str(datetime.now()).replace(":",
"-").replace(" ",
"_").split(".")[0]
args.model_name = (
labels = np.nan_to_num(labels).astype("float32")
g = pgl.Graph.batch(graph_list)
multihop_graphs = []
for g_list in multihop_graph_list:
multihop_graphs.append(pgl.Graph.batch(g_list))
return g, multihop_graphs, labels, batch_valid
if __name__ == "__main__":
config = prepare_config("pcba_config.yaml", isCreate=False, isSave=False)
raw_dataset = GraphPropPredDataset(name=config.dataset_name)
ds = MolDataset(config, raw_dataset, transform=make_multihop_edges)
splitted_index = raw_dataset.get_idx_split()
train_ds = Subset(ds, splitted_index['train'], mode='train')
valid_ds = Subset(ds, splitted_index['valid'], mode="valid")
test_ds = Subset(ds, splitted_index['test'], mode="test")
Fn = CollateFn(config)
loader = Dataloader(train_ds,
batch_size=3,
shuffle=False,
num_workers=4,
collate_fn=Fn)
for batch_data in loader:
print("batch", batch_data[0][0].node_feat)
g = pgl.Graph.batch(batch_data[0])
print(g.node_feat)
time.sleep(3)
def main(args):
if paddle.distributed.get_world_size() > 1:
paddle.distributed.init_parallel_env()
data = pgl.dataset.RedditDataset(args.normalize, args.symmetry)
log.info("Preprocess finish")
log.info("Train Examples: %s" % len(data.train_index))
log.info("Val Examples: %s" % len(data.val_index))
log.info("Test Examples: %s" % len(data.test_index))
log.info("Num nodes %s" % data.graph.num_nodes)
log.info("Num edges %s" % data.graph.num_edges)
log.info("Average Degree %s" % np.mean(data.graph.indegree()))
graph = data.graph
train_index = data.train_index
val_index = data.val_index
test_index = data.test_index
train_label = data.train_label
val_label = data.val_label
test_label = data.test_label
model = GraphSage(
input_size=data.feature.shape[-1],
num_class=data.num_classes,
hidden_size=args.hidden_size,
num_layers=len(args.samples))
model = paddle.DataParallel(model)
criterion = paddle.nn.loss.CrossEntropyLoss()
optim = paddle.optimizer.Adam(
learning_rate=args.lr,
parameters=model.parameters(),
weight_decay=0.001)
feature = paddle.to_tensor(data.feature)
train_ds = ShardedDataset(train_index, train_label)
val_ds = ShardedDataset(val_index, val_label)
test_ds = ShardedDataset(test_index, test_label)
collate_fn = partial(batch_fn, graph=graph, samples=args.samples)
train_loader = Dataloader(
train_ds,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.sample_workers,
collate_fn=collate_fn)
val_loader = Dataloader(
test_ds,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.sample_workers,
collate_fn=collate_fn)
test_loader = Dataloader(
test_ds,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.sample_workers,
collate_fn=collate_fn)
cal_val_acc = []
cal_test_acc = []
cal_val_loss = []
for epoch in tqdm.tqdm(range(args.epoch)):
train_loss, train_acc = train(train_loader, model, feature, criterion,
optim)
log.info("Runing epoch:%s\t train_loss:%s\t train_acc:%s", epoch,
train_loss, train_acc)
val_loss, val_acc = eval(val_loader, model, feature, criterion)
cal_val_acc.append(val_acc)
cal_val_loss.append(val_loss)
log.info("Runing epoch:%s\t val_loss:%s\t val_acc:%s", epoch, val_loss,
val_acc)
test_loss, test_acc = eval(test_loader, model, feature, criterion)
cal_test_acc.append(test_acc)
log.info("Runing epoch:%s\t test_loss:%s\t test_acc:%s", epoch,
test_loss, test_acc)
log.info("Runs %s: Model: %s Best Test Accuracy: %f" %
(0, "graphsage", cal_test_acc[np.argmax(cal_val_acc)]))
test_chain_list = [p.strip() for p in open(args.test_file)]
saved_state_dict = paddle.load(args.model_name)
# In-place assignment
add_saved_args_and_params(args, saved_state_dict)
test_dataset = MyDataset(
test_chain_list,
args.n_channels,
args.pad_len,
args.protein_chain_graphs,
args.cmap_thresh,
args.label_data_path,
args.use_cache,
)
test_loader = Dataloader(test_dataset,
batch_size=args.batch_size,
collate_fn=test_dataset.collate_fn)
args.n_labels = test_dataset.n_labels
model = DeepFRI(args)
model.set_state_dict(saved_state_dict["model"])
model.eval()
print(f"\n{args.task}: Testing on {len(test_dataset)} protein samples.")
print(f"Starting at {datetime.now()}\n")
print(args)
test(model, test_loader)
def collate_fn(batch_data):
graphs = []
labels = []
for g, l in batch_data:
graphs.append(g)
labels.append(l)
labels = np.array(labels, dtype="int64").reshape(-1, 1)
return graphs, labels
if __name__ == "__main__":
gindataset = GINDataset("./gin_data/",
"MUTAG",
self_loop=True,
degree_as_nlabel=False)
loader = Dataloader(gindataset,
batch_size=3,
shuffle=False,
num_workers=1,
collate_fn=collate_fn)
cc = 0
for batch in loader:
g, label = batch
print(label)
cc += 1
if cc == 2:
break
def infer(config):
model = getattr(M, config.model_type)(config)
log.info("infer model from %s" % config.infer_from)
model.set_state_dict(paddle.load(config.infer_from))
log.info("loading data")
ds = getattr(DS, config.dataset_type)(config)
split_idx = ds.get_idx_split()
train_ds = DS.Subset(ds, split_idx['train'], mode='train')
valid_ds = DS.Subset(ds, split_idx['valid'], mode='valid')
test_ds = DS.Subset(ds, split_idx['test'], mode='test')
log.info("Train exapmles: %s" % len(train_ds))
log.info("Valid exapmles: %s" % len(valid_ds))
log.info("Test exapmles: %s" % len(test_ds))
train_loader = Dataloader(train_ds,
batch_size=config.batch_size,
shuffle=False,
num_workers=config.num_workers,
collate_fn=DS.CollateFn(config),
drop_last=True)
valid_loader = Dataloader(valid_ds,
batch_size=config.valid_batch_size,
shuffle=False,
num_workers=1,
collate_fn=DS.CollateFn(config))
test_loader = Dataloader(test_ds,
batch_size=config.valid_batch_size,
shuffle=False,
num_workers=1,
collate_fn=DS.CollateFn(config))
try:
task_name = config.infer_from.split("/")[-2]
except:
task_name = "ogb_kdd"
log.info("task_name: %s" % task_name)
### automatic evaluator. takes dataset name as input
evaluator = PCQM4MEvaluator()
# ---------------- valid ----------------------- #
# log.info("validating ...")
# pred_dict = evaluate(model, valid_loader)
#
# log.info("valid MAE: %s" % evaluator.eval(pred_dict)["mae"])
# valid_output_path = os.path.join(config.output_dir, task_name)
# make_dir(valid_output_path)
# valid_output_file = os.path.join(valid_output_path, "valid_mae.txt")
#
# log.info("saving valid result to %s" % valid_output_file)
# with open(valid_output_file, 'w') as f:
# for y_pred, idx in zip(pred_dict['y_pred'], split_idx['valid']):
# smiles, label = ds.raw_dataset[idx]
# f.write("%s\t%s\t%s\n" % (y_pred, label, smiles))
#
# ---------------- test ----------------------- #
log.info("testing ...")
pred_dict = evaluate(model, test_loader)
test_output_path = os.path.join(config.output_dir, task_name)
make_dir(test_output_path)
test_output_file = os.path.join(test_output_path, "test_mae.txt")
log.info("saving test result to %s" % test_output_file)
with open(test_output_file, 'w') as f:
for y_pred, idx in zip(pred_dict['y_pred'], split_idx['test']):
smiles, label = ds.raw_dataset[idx]
f.write("%s\t%s\n" % (y_pred, smiles))
log.info("saving submition format to %s" % test_output_path)
evaluator.save_test_submission({'y_pred': pred_dict['y_pred']},
test_output_path)
def main(args):
role = role_maker.PaddleCloudRoleMaker()
fleet.init(role)
data = pgl.dataset.RedditDataset(args.normalize, args.symmetry)
log.info("Preprocess finish")
log.info("Train Examples: %s" % len(data.train_index))
log.info("Val Examples: %s" % len(data.val_index))
log.info("Test Examples: %s" % len(data.test_index))
log.info("Num nodes %s" % data.graph.num_nodes)
log.info("Num edges %s" % data.graph.num_edges)
log.info("Average Degree %s" % np.mean(data.graph.indegree()))
graph = data.graph
train_index = data.train_index
val_index = data.val_index
test_index = data.test_index
train_label = data.train_label
val_label = data.val_label
test_label = data.test_label
loss, acc = build_net(
input_size=data.feature.shape[-1],
num_class=data.num_classes,
hidden_size=args.hidden_size,
num_layers=len(args.samples))
test_program = paddle.static.default_main_program().clone(for_test=True)
strategy = fleet.DistributedStrategy()
strategy.a_sync = True
optimizer = paddle.fluid.optimizer.Adam(learning_rate=args.lr)
optimizer = fleet.distributed_optimizer(optimizer, strategy)
optimizer.minimize(loss)
if fleet.is_server():
fleet.init_server()
fleet.run_server()
else:
place = paddle.CPUPlace()
exe = paddle.static.Executor(place)
exe.run(paddle.static.default_startup_program())
fleet.init_worker()
train_ds = ShardedDataset(train_index, train_label)
valid_ds = ShardedDataset(val_index, val_label)
test_ds = ShardedDataset(test_index, test_label)
collate_fn = partial(batch_fn, graph=graph, samples=args.samples)
train_loader = Dataloader(
train_ds,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.sample_workers,
collate_fn=collate_fn)
valid_loader = Dataloader(
valid_ds,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.sample_workers,
collate_fn=collate_fn)
test_loader = Dataloader(
test_ds,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.sample_workers,
collate_fn=collate_fn)
compiled_prog, cpu_num = setup_compiled_prog(loss)
for epoch in tqdm.tqdm(range(args.epoch)):
train_loss, train_acc = run(train_loader,
data.feature,
exe,
compiled_prog,
loss,
acc,
phase="train",
cpu_num=cpu_num)
valid_loss, valid_acc = run(valid_loader,
data.feature,
exe,
test_program,
loss,
acc,
phase="valid",
cpu_num=1)
log.info("Epoch %s Valid-Loss %s Valid-Acc %s" %
(epoch, valid_loss, valid_acc))
test_loss, test_acc = run(test_loader,
data.feature,
exe,
test_program,
loss,
acc,
phase="test",
cpu_num=1)
log.info("Epoch %s Test-Loss %s Test-Acc %s" %
(epoch, test_loss, test_acc))
fleet.stop_worker()
parser.add_argument('--epochs', type=int, default=300)
parser.add_argument("--num_convs", type=int, default=2)
parser.add_argument("--hidden_dim", type=int, default=128)
parser.add_argument("--infeat_dim", type=int, default=36)
parser.add_argument("--dense_dims", type=str, default='128*4,128*2,128')
parser.add_argument('--num_heads', type=int, default=4)
parser.add_argument('--cut_dist', type=float, default=5.)
parser.add_argument('--num_angle', type=int, default=6)
parser.add_argument('--merge_b2b', type=str, default='cat')
parser.add_argument('--merge_b2a', type=str, default='mean')
args = parser.parse_args()
args.activation = F.relu
args.dense_dims = [eval(dim) for dim in args.dense_dims.split(',')]
if int(args.cuda) == -1:
paddle.set_device('cpu')
else:
paddle.set_device('gpu:%s' % args.cuda)
tst_complex = ComplexDataset(args.data_dir, "%s_test" % args.dataset, args.cut_dist, args.num_angle)
tst_loader = Dataloader(tst_complex, args.batch_size, shuffle=False, num_workers=1, collate_fn=collate_fn)
model = SIGN(args)
path = os.path.join(args.model_dir, 'saved_model')
load_state_dict = paddle.load(path)
model.set_state_dict(load_state_dict['model'])
rmse_tst, mae_tst, sd_tst, r_tst = evaluate(model, tst_loader)
print('Test - RMSE: %.6f, MAE: %.6f, SD: %.6f, R: %.6f.\n' % (rmse_tst, mae_tst, sd_tst, r_tst))
def main():
# Training settings
parser = argparse.ArgumentParser(
description='GNN baselines on pcqm4m with PGL')
parser.add_argument('--use_cuda', action='store_true')
parser.add_argument('--device',
type=int,
default=0,
help='which gpu to use if any (default: 0)')
parser.add_argument(
'--gnn',
type=str,
default='gin-virtual',
help=
'GNN gin, gin-virtual, or gcn, or gcn-virtual (default: gin-virtual)')
parser.add_argument(
'--graph_pooling',
type=str,
default='sum',
help='graph pooling strategy mean or sum (default: sum)')
parser.add_argument('--drop_ratio',
type=float,
default=0,
help='dropout ratio (default: 0)')
parser.add_argument(
'--num_layers',
type=int,
default=5,
help='number of GNN message passing layers (default: 5)')
parser.add_argument(
'--emb_dim',
type=int,
default=600,
help='dimensionality of hidden units in GNNs (default: 600)')
parser.add_argument('--train_subset', action='store_true')
parser.add_argument('--batch_size',
type=int,
default=256,
help='input batch size for training (default: 256)')
parser.add_argument('--epochs',
type=int,
default=100,
help='number of epochs to train (default: 100)')
parser.add_argument('--num_workers',
type=int,
default=1,
help='number of workers (default: 1)')
parser.add_argument('--log_dir',
type=str,
default="",
help='tensorboard log directory')
parser.add_argument('--checkpoint_dir',
type=str,
default='',
help='directory to save checkpoint')
parser.add_argument('--save_test_dir',
type=str,
default='',
help='directory to save test submission file')
args = parser.parse_args()
print(args)
random.seed(42)
np.random.seed(42)
paddle.seed(42)
if not args.use_cuda:
paddle.set_device("cpu")
### automatic dataloading and splitting
class Config():
def __init__(self):
self.base_data_path = "./dataset"
config = Config()
ds = MolDataset(config)
split_idx = ds.get_idx_split()
train_ds = Subset(ds, split_idx['train'])
valid_ds = Subset(ds, split_idx['valid'])
test_ds = Subset(ds, split_idx['test'])
print("Train exapmles: ", len(train_ds))
print("Valid exapmles: ", len(valid_ds))
print("Test exapmles: ", len(test_ds))
### automatic evaluator. takes dataset name as input
evaluator = PCQM4MEvaluator()
train_loader = Dataloader(train_ds,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
collate_fn=CollateFn())
valid_loader = Dataloader(valid_ds,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers,
collate_fn=CollateFn())
if args.save_test_dir is not '':
test_loader = Dataloader(test_ds,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers,
collate_fn=CollateFn())
if args.checkpoint_dir is not '':
os.makedirs(args.checkpoint_dir, exist_ok=True)
shared_params = {
'num_layers': args.num_layers,
'emb_dim': args.emb_dim,
'drop_ratio': args.drop_ratio,
'graph_pooling': args.graph_pooling
}
if args.gnn == 'gin':
model = GNN(gnn_type='gin', virtual_node=False, **shared_params)
elif args.gnn == 'gin-virtual':
model = GNN(gnn_type='gin', virtual_node=True, **shared_params)
elif args.gnn == 'gcn':
model = GNN(gnn_type='gcn', virtual_node=False, **shared_params)
elif args.gnn == 'gcn-virtual':
model = GNN(gnn_type='gcn', virtual_node=True, **shared_params)
else:
raise ValueError('Invalid GNN type')
num_params = sum(p.numel() for p in model.parameters())
print(f'#Params: {num_params}')
if args.log_dir is not '':
writer = SummaryWriter(log_dir=args.log_dir)
best_valid_mae = 1000
scheduler = paddle.optimizer.lr.StepDecay(learning_rate=0.001,
step_size=300,
gamma=0.25)
optimizer = paddle.optimizer.Adam(learning_rate=scheduler,
parameters=model.parameters())
msg = "ogbg_lsc_paddle_baseline\n"
for epoch in range(1, args.epochs + 1):
print("=====Epoch {}".format(epoch))
print('Training...')
train_mae = train(model, train_loader, optimizer)
print('Evaluating...')
valid_mae = eval(model, valid_loader, evaluator)
print({'Train': train_mae, 'Validation': valid_mae})
if args.log_dir is not '':
writer.add_scalar('valid/mae', valid_mae, epoch)
writer.add_scalar('train/mae', train_mae, epoch)
if valid_mae < best_valid_mae:
best_valid_mae = valid_mae
if args.checkpoint_dir is not '':
print('Saving checkpoint...')
paddle.save(
model.state_dict(),
os.path.join(args.checkpoint_dir, 'checkpoint.pdparams'))
if args.save_test_dir is not '':
print('Predicting on test data...')
y_pred = test(model, test_loader)
print('Saving test submission file...')
evaluator.save_test_submission({'y_pred': y_pred},
args.save_test_dir)
scheduler.step()
print(f'Best validation MAE so far: {best_valid_mae}')
try:
msg +="Epoch: %d | Train: %.6f | Valid: %.6f | Best Valid: %.6f\n" \
% (epoch, train_mae, valid_mae, best_valid_mae)
print(msg)
except:
continue
if args.log_dir is not '':
writer.close()