ExploringMachineOlfaction/gridsearch_ml_embeddings.py at main · rrrrn/ExploringMachineOlfaction · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
import pandas as pd
import numpy as np
import yaml
import os
from sklearn.model_selection import KFold
from sklearn.linear_model import LinearRegression
from sklearn.svm import SVR
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.neighbors import KNeighborsRegressor
import warnings
from tqdm import tqdm
from joblib import dump, load
from gridsearch_ml_mordred import *
from embeddings import learn_embeddings


if __name__ == "__main__":
    """
    This script carries out grid-search for ML models on GNN-learned embeddings specific to each dataset
    GNN-learned embeddings are learn
    """
    # model type
    modelsets = [
        LinearRegression(),
        SVR(),
        KNeighborsRegressor(),
        GradientBoostingRegressor(),
        RandomForestRegressor(),
    ]
    randomseed = 432
    datasetname = "keller"
    metricname = ["explained_variance", "neg_mean_squared_error"]
    cvsplit = KFold(n_splits=5, shuffle=True, random_state=randomseed)

    path = f"results/{datasetname}/gnn_regr"  ## path to get learned embeddings

    ## retrieve learned embeddings and predicting target
    if datasetname == "keller":
        gnnmodel = "1440"
    elif datasetname == "dravnieks":
        gnnmodel = "1413"

    ## if embeddings are not computed, compute them
    if not os.path.isfile(f"{path}/{gnnmodel}_embeddings.cs"):
        learn_embeddings(datasetname=datasetname)
    targetpath = f"results/{datasetname}/embeddings"  ## path to save model details
    if not os.path.isdir(targetpath):
        os.makedirs(targetpath)

    X = pd.read_csv(f"{path}/{gnnmodel}_embeddings.csv").iloc[:, 1:]
    y = pd.read_csv(f"{path}/{gnnmodel}_target.csv").iloc[:, 1:]
    data = prepare_data(datasetname, numpy_form=False)
    col = data["target"].columns

    assert y.shape[1] == len(col)

    ## setup log info
    for ml_model in modelsets:
        model_name = str(ml_model)[: len(str(ml_model)) - 2]
        logger = log(path="logs/", file=model_name.lower() + ".logs")
        logger.info("-" * 15 + "Start Session!" + "-" * 15)

        # load grid parameters
        with open(
            "configs/param_search/" + model_name.lower() + ".yaml", "r"
        ) as stream:
            parameters = yaml.safe_load(stream)

        if not os.path.isdir(f"{targetpath}/best_models/{model_name}"):
            os.makedirs(f"{targetpath}/best_models/{model_name}")
        if not os.path.isdir(f"{targetpath}/best_params/"):
            os.makedirs(f"{targetpath}/best_params/")
        if not os.path.isdir(f"{targetpath}/metrics/"):
            os.makedirs(f"{targetpath}/metrics/")

        logger.info("{} regressor parameter grid search".format(model_name))

        ## grid search
        bestscore, best_param = dict(), dict()
        for i in tqdm(range(len(y.columns))):
            descriptor_name = col[i]
            if "/" in descriptor_name:
                descriptor_name = descriptor_name.replace("/", "_")
            bestscore[descriptor_name] = np.zeros(2)
            grid_search = GridSearchCV(
                ml_model,
                parameters,
                cv=cvsplit,
                scoring=(metricname),
                refit="explained_variance",
                n_jobs=-1,
                verbose=1,
            )
            grid_search.fit(X, y.iloc[:, i])
            results = grid_search.cv_results_

            for i, scorer in enumerate(metricname):
                best_index = np.nonzero(results["rank_test_%s" % scorer] == 1)[0][0]
                bestscore[descriptor_name][i] = results["mean_test_%s" % scorer][
                    best_index
                ]

            best_param[descriptor_name] = list(grid_search.best_params_.values())

            dump(
                grid_search.best_estimator_,
                f"{targetpath}/best_models/{model_name}/{descriptor_name}.joblib",
            )

        best_param = (pd.DataFrame(best_param, index=list(parameters.keys()))).T
        best_param.to_csv(f"{targetpath}/best_params/{model_name}.csv")
        best_score = pd.DataFrame(bestscore, index=metricname).T
        best_score.to_csv(f"{targetpath}/metrics/{model_name}.csv")