resolve conflict

test/nas/nclf_dgl.py

@@ -1,113 +0,0 @@
-import os
-import sys
-import logging
-logging.basicConfig(level=logging.INFO)
-
-sys.path.append("../../")
-print(os.getcwd())
-os.environ["AUTOGL_BACKEND"] = "dgl"
-from autogl.backend import DependentBackend
-import dgl
-from dgl.data import CoraGraphDataset, CiteseerGraphDataset, PubmedGraphDataset
-import torch
-import torch.nn.functional as F
-from autogl.module.nas.space.single_path import SinglePathNodeClassificationSpace
-from autogl.module.nas.space.graph_nas import GraphNasNodeClassificationSpace
-from autogl.module.nas.space.graph_nas_macro import GraphNasMacroNodeClassificationSpace
-from autogl.module.nas.estimator.one_shot import OneShotEstimator
-from autogl.module.nas.estimator.train_scratch import TrainEstimator
-from autogl.module.nas.backend import bk_feat, bk_label
-from autogl.module.nas.algorithm import Darts,RL,GraphNasRL,Enas,RandomSearch,Spos
-from pdb import set_trace
-import numpy as np
-from autogl.datasets import build_dataset_from_name
-from autogl.solver.utils import set_seed
-set_seed(202106)
-
-import nni.retiarii.strategy as strategy
-
-
-if __name__ == '__main__':
-    isdgl=DependentBackend.is_dgl()
-    print('Using backend: %s'%('dgl' if isdgl else 'pyg'))
-    data = CoraGraphDataset()
-    di=bk_feat(data[0]).shape[1]
-    do=len(np.unique(bk_label(data[0])))
-
-    print("evolutionary + singlepath ")
-    space=SinglePathNodeClassificationSpace().cuda()
-    space.instantiate(input_dim=di,output_dim=do)
-    esti=OneShotEstimator()
-    algo=Spos(cycles=200)
-    algo.search(space,data,esti)
-
-    print("evolutionary + graphnas ")
-    space=GraphNasNodeClassificationSpace().cuda()
-    space.instantiate(input_dim=di,output_dim=do)
-    esti=OneShotEstimator()
-    algo=Spos(cycles=200)
-    algo.search(space,data,esti)
-
-    print("Random search + graphnas ")
-    space=GraphNasNodeClassificationSpace().cuda()
-    space.instantiate(input_dim=di,output_dim=do)
-    esti=OneShotEstimator()
-    algo=RandomSearch(num_epochs=10)
-    algo.search(space,data,esti)
-    
-    print("Random search + singlepath ")
-    space=SinglePathNodeClassificationSpace().cuda()
-    space.instantiate(input_dim=di,output_dim=do)
-    esti=OneShotEstimator()
-    algo=RandomSearch(num_epochs=10)
-    algo.search(space,data,esti)
-
-    print("rl + graphnas ")
-    space=GraphNasNodeClassificationSpace().cuda()
-    space.instantiate(input_dim=di,output_dim=do)
-    esti=OneShotEstimator()
-    algo=RL(num_epochs=10)
-    algo.search(space,data,esti)
-
-    print("graphnasrl + graphnas ")
-    space=GraphNasNodeClassificationSpace().cuda()
-    space.instantiate(input_dim=di,output_dim=do)
-    esti=OneShotEstimator()
-    algo=GraphNasRL(num_epochs=10)
-    algo.search(space,data,esti)
-
-    print("enas + graphnas ")
-    space=GraphNasNodeClassificationSpace().cuda()
-    space.instantiate(input_dim=di,output_dim=do)
-    esti=OneShotEstimator()
-    algo=Enas(num_epochs=10)
-    algo.search(space,data,esti)
-
-    print("darts + graphnas ")
-    space=GraphNasNodeClassificationSpace().cuda()
-    space.instantiate(input_dim=di,output_dim=do)
-    esti=OneShotEstimator()
-    algo=Darts(num_epochs=10)
-    algo.search(space,data,esti)
-
-    print("darts + singlepath ")
-    space=SinglePathNodeClassificationSpace().cuda()
-    space.instantiate(input_dim=di,output_dim=do)
-    esti=OneShotEstimator()
-    algo=Darts(num_epochs=10)
-    algo.search(space,data,esti)
-
-    print("Random search + graphnas macro")
-    space=GraphNasMacroNodeClassificationSpace().cuda()
-    space.instantiate(input_dim=di,output_dim=do)
-    esti=OneShotEstimator()
-    algo=RandomSearch(num_epochs=10)
-    algo.search(space,data,esti)
-
-    print("RL + graphnas macro")
-    space=GraphNasMacroNodeClassificationSpace().cuda()
-    space.instantiate(input_dim=di,output_dim=do)
-    esti=OneShotEstimator()
-    algo=RL(num_epochs=10)
-    algo.search(space,data,esti)
-

test/nas/node_classification.py

@@ -0,0 +1,170 @@
+"""
+Test file for nas on node classification
+
+AUTOGL_BACKEND=pyg python test/nas/node_classification.py
+AUTOGL_BACKEND=dgl python test/nas/node_classification.py
+
+TODO: make it a unit test file to test all the possible combinations
+"""
+
+import os
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+from autogl.backend import DependentBackend
+
+if DependentBackend.is_dgl():
+    from autogl.module.model.dgl import BaseModel
+    from dgl.data import CoraGraphDataset
+elif DependentBackend.is_pyg():
+    from torch_geometric.datasets import Planetoid
+    from autogl.module.model.pyg import BaseModel
+
+import torch
+import torch.nn.functional as F
+from autogl.module.nas.space.single_path import SinglePathNodeClassificationSpace
+from autogl.module.nas.space.graph_nas import GraphNasNodeClassificationSpace
+from autogl.module.nas.space.graph_nas_macro import GraphNasMacroNodeClassificationSpace
+from autogl.module.nas.estimator.one_shot import OneShotEstimator
+from autogl.module.nas.backend import bk_feat, bk_label
+from autogl.module.nas.algorithm import Darts, RL, GraphNasRL, Enas, RandomSearch,Spos
+import numpy as np
+from autogl.solver.utils import set_seed
+
+set_seed(202106)
+
+def test_model(model, data=None, check_children=False):
+    """
+    Test model interface.
+
+    Interface
+    ---------
+    - model.from_hyper_parameter()
+    - model.model.forward()
+    - model.to()
+    - model.initialize()
+    """
+    assert isinstance(model, BaseModel)
+    assert hasattr(model, "to")
+    assert hasattr(model, "initialize")
+    model.initialize()
+    model.to("cuda")
+    if data is not None:
+        data = data.to("cuda")
+
+    assert hasattr(model, "model")
+    __model = model.model
+    assert isinstance(__model, torch.nn.Module)
+
+    if data is not None:
+        __model.forward(data)
+
+    # FIXME: we can only perform tests when hyper_parameter_space is []
+    if len(model.hyper_parameter_space) == 0:
+        model_2 = model.from_hyper_parameter({})
+        if check_children:
+            test_model(model_2, data)
+
+
+if __name__ == "__main__":
+
+    print("Testing backend: {}".format("dgl" if DependentBackend.is_dgl() else "pyg"))
+
+    if DependentBackend.is_dgl():
+        dataset = CoraGraphDataset()
+    else:
+        dataset = Planetoid(os.path.expanduser("~/.cache-autogl"), "Cora")
+
+    data = dataset[0]
+
+    di = bk_feat(data).shape[1]
+    do = len(np.unique(bk_label(data)))
+
+    print("evolutionary + singlepath ")
+    space=SinglePathNodeClassificationSpace().cuda()
+    space.instantiate(input_dim=di,output_dim=do)
+    esti=OneShotEstimator()
+    algo=Spos(cycles=200)
+    model = algo.search(space, dataset, esti)
+    test_model(model, data, True)
+
+    print("evolutionary + graphnas ")
+    space=GraphNasNodeClassificationSpace().cuda()
+    space.instantiate(input_dim=di,output_dim=do)
+    esti=OneShotEstimator()
+    algo=Spos(cycles=200)
+    model = algo.search(space, dataset, esti)
+    test_model(model, data, True)
+
+    print("Random search + graphnas ")
+    space = GraphNasNodeClassificationSpace().cuda()
+    space.instantiate(input_dim=di, output_dim=do)
+    esti = OneShotEstimator()
+    algo = RandomSearch(num_epochs=10)
+    model = algo.search(space, dataset, esti)
+    test_model(model, data, True)
+
+    print("Random search + singlepath ")
+    space = SinglePathNodeClassificationSpace().cuda()
+    space.instantiate(input_dim=di, output_dim=do)
+    esti = OneShotEstimator()
+    algo = RandomSearch(num_epochs=10)
+    model = algo.search(space, dataset, esti)
+    test_model(model, data, True)
+
+    print("rl + graphnas ")
+    space = GraphNasNodeClassificationSpace().cuda()
+    space.instantiate(input_dim=di, output_dim=do)
+    esti = OneShotEstimator()
+    algo = RL(num_epochs=10)
+    model = algo.search(space, dataset, esti)
+    test_model(model, data, True)
+
+    print("graphnasrl + graphnas ")
+    space = GraphNasNodeClassificationSpace().cuda()
+    space.instantiate(input_dim=di, output_dim=do)
+    esti = OneShotEstimator()
+    algo = GraphNasRL(num_epochs=10)
+    model = algo.search(space, dataset, esti)
+    test_model(model, data, True)
+
+    print("enas + graphnas ")
+    space = GraphNasNodeClassificationSpace().cuda()
+    space.instantiate(input_dim=di, output_dim=do)
+    esti = OneShotEstimator()
+    algo = Enas(num_epochs=10)
+    model = algo.search(space, dataset, esti)
+    test_model(model, data, True)
+
+    print("darts + graphnas ")
+    space = GraphNasNodeClassificationSpace(con_ops=['concat']).cuda()
+    space.instantiate(input_dim=di, output_dim=do)
+    esti = OneShotEstimator()
+    algo = Darts(num_epochs=10)
+    model = algo.search(space, dataset, esti)
+    test_model(model, data, True)
+    
+    print("darts + singlepath ")
+    space = SinglePathNodeClassificationSpace().cuda()
+    space.instantiate(input_dim=di, output_dim=do)
+    esti = OneShotEstimator()
+    algo = Darts(num_epochs=10)
+    model = algo.search(space, dataset, esti)
+    test_model(model, data, True)
+
+    print("Random search + graphnas macro")
+    space = GraphNasMacroNodeClassificationSpace().cuda()
+    space.instantiate(input_dim=di, output_dim=do)
+    esti = OneShotEstimator()
+    algo = RandomSearch(num_epochs=10)
+    model = algo.search(space, dataset, esti)
+    test_model(model, data, True)
+
+    print("RL + graphnas macro")
+    space = GraphNasMacroNodeClassificationSpace().cuda()
+    space.instantiate(input_dim=di, output_dim=do)
+    esti = OneShotEstimator()
+    algo = RL(num_epochs=10)
+    model = algo.search(space, dataset, esti)
+    test_model(model, data, True)