AutoGL/test/performance/node_classification/dgl/solver.py

"""
Performance check of AutoGL solver
"""
import os
import numpy as np
from tqdm import tqdm

os.environ["AUTOGL_BACKEND"] = "dgl"

from autogl.solver import AutoNodeClassifier
from autogl.datasets import build_dataset_from_name
import logging

logging.basicConfig(level=logging.ERROR)

def fixed(**kwargs):
    return [{
        'parameterName': k,
        "type": "FIXED",
        "value": v
    } for k, v in kwargs.items()]

if __name__ == '__main__':

    import argparse
    parser = argparse.ArgumentParser('dgl solver')
    parser.add_argument('--device', type=str, default='cuda')
    parser.add_argument('--dataset', type=str, choices=['Cora', 'CiteSeer', 'PubMed'], default='Cora')
    parser.add_argument('--repeat', type=int, default=50)
    parser.add_argument('--model', type=str, choices=['gat', 'gcn', 'sage'], default='gat')
    parser.add_argument('--lr', type=float, default=0.01)
    parser.add_argument('--weight_decay', type=float, default=0.0)
    parser.add_argument('--epoch', type=int, default=200)

    args = parser.parse_args()

    # seed = 100
    dataset = build_dataset_from_name(args.dataset.lower())
    label = dataset[0].nodes.data['label'][dataset[0].nodes.data['test_mask']].numpy()
    accs = []

    for seed in tqdm(range(args.repeat)):

        if args.model == 'gat':
            model_hp = {
                # hp from model
                "num_layers": 2,
                "hidden": [8],
                "heads": 8,
                "dropout": 0.6,
                "act": "elu",
            }
        elif args.model == 'gcn':
            model_hp = {
                "num_layers": 2,
                "hidden": [16],
                "dropout": 0.5,
                "act": "relu"
            }
        elif args.model == 'sage':
            model_hp = {
                "num_layers": 2,
                "hidden": [64],
                "dropout": 0.5,
                "act": "relu",
                "agg": "gcn",
            }
        
        solver = AutoNodeClassifier(
            feature_module=None,
            graph_models=(args.model,),
            ensemble_module=None,
            max_evals=1,
            hpo_module='random',
            trainer_hp_space=fixed(**{
                "max_epoch": args.epoch,
                "early_stopping_round": args.epoch + 1,
                "lr": args.lr,
                "weight_decay": args.weight_decay,
            }),
            model_hp_spaces=[fixed(**model_hp)]
        )

        solver.fit(dataset, evaluation_method=['acc'], seed=seed)
        output = solver.predict(dataset)
        acc = (output == label).astype('float').mean()
        accs.append(acc)
    print('{:.4f} ~ {:.4f}'.format(np.mean(accs), np.std(accs)))