MultiObjectiveSurrogateOptimization/interface/_ca1_inference.py at main · GazzolaLab/MultiObjectiveSurrogateOptimization · 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
from machinable import Interface, get, Index
import os


class _Ca1Inference(Interface):
    class Config:
        index: str = ""

    def populations(self):
        return [
            "SCA",
            "IVY",
            "PVBC",
            "CCKBC",
            "AAC",
            "BS",
            "OLM",
            "NGFC",
            "IS",
        ]

    def samplers(self):
        return ["slh", "lh", "mc", "sobol"]

    def launch(self):
        sampler = "mc"
        trial = 0

        index = self.config.index
        if index == "":
            index = Index.get().config.directory

        for nm in self.populations():
            for model in [
                "resnet-o",
                "resnet-c+o",
                "fttransformer-o",
                "fttransformer-c+o",
                "megp",
            ]:
                with get("machinable.index", {"directory": index}):
                    with get("machinable.scope", {"trial": trial}):
                        experiment = get(
                            "interface.sopt_modeling",
                            [
                                f"""~from_protocol("benchmarks/ca1_pinsky_rinzel_modeling/config/CA1_{nm}.yaml")""",
                                {
                                    "dopt_params.surrogate_method_name": "gpr",
                                    "dopt_params.initial_method": sampler,
                                },
                            ],
                        )

                        version = {
                            "run": experiment.uuid,
                            "index": os.path.abspath(index),
                            "model": model,
                        }

                get(
                    "interface.sopt_inference",
                    version,
                ).launch().save_attribute("model_name", f"{nm}-{model}")

    def models(self):
        models = []
        for c in self.components:
            models.append(c.load_attribute("model_name"))
        return models

    def export(self):
        for c in self.components:
            print(
                "cp "
                + c.local_directory("results.p")
                + " ./export/"
                + c.load_attribute("model_name")
                + ".p"
            )