Skip to content

quast_decisiontree.nodes.optimizer

quast_decisiontree.nodes.optimizer

Nodes for selecting and configuring the VQA optimizer.

opt_builders module-attribute 

opt_builders = {
    (builder.name): builder
    for builder in (opt.OptimizerBuilder.instances)
}

SelectOptimizerNode

Bases: Node

Selects the optimizer for VQA optimization.

Modifications at runtime: - optimizer_type: - {str}: name of the optimizer (e.g., SPSA)

Source code in src/quast_decisiontree/nodes/optimizer.py 
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
class SelectOptimizerNode(Node):
    """Selects the optimizer for VQA optimization.

    Modifications at runtime:
    - optimizer_type:
        - {str}: name of the optimizer (e.g., SPSA)
    """

    _known_children = ["OptimizerSetupNode"]
    _path_keys = dict(optimizer_type=PathKey(str, tuple(opt_builders)))

    def __init__(self, children: list) -> None:
        super().__init__(requires=[], creates="optimizer_type", children=children)
        self.query = MultiChoiceQuery(
            question="Which optimizer do you want to use?",
            answers={key: val.description for key, val in opt_builders.items()},
            default="Powell",
            name="optimizer_type",
        )

    def execute(self, problem_data: dict, path_info: dict) -> dict:
        problem_data["optimizer_type"] = path_info.get("optimizer_type")
        if problem_data["optimizer_type"] is None:
            problem_data["optimizer_type"] = self.query.input()
            path_info["optimizer_type"] = problem_data["optimizer_type"]
        return dict(optimizer_from=opt_builders[problem_data["optimizer_type"]])

query instance-attribute 

query = MultiChoiceQuery(
    question="Which optimizer do you want to use?",
    answers={
        key: (val.description)
        for key, val in (opt_builders.items())
    },
    default="Powell",
    name="optimizer_type",
)

__init__ 

__init__(children)
Source code in src/quast_decisiontree/nodes/optimizer.py 
30
31
32
33
34
35
36
37
def __init__(self, children: list) -> None:
    super().__init__(requires=[], creates="optimizer_type", children=children)
    self.query = MultiChoiceQuery(
        question="Which optimizer do you want to use?",
        answers={key: val.description for key, val in opt_builders.items()},
        default="Powell",
        name="optimizer_type",
    )

execute 

execute(problem_data, path_info)
Source code in src/quast_decisiontree/nodes/optimizer.py 
39
40
41
42
43
44
def execute(self, problem_data: dict, path_info: dict) -> dict:
    problem_data["optimizer_type"] = path_info.get("optimizer_type")
    if problem_data["optimizer_type"] is None:
        problem_data["optimizer_type"] = self.query.input()
        path_info["optimizer_type"] = problem_data["optimizer_type"]
    return dict(optimizer_from=opt_builders[problem_data["optimizer_type"]])

OptimizerSetupNode

Bases: Node

Sets the hyperparameters of the optimizer.

Modifications at runtime: - hyperparam_values: - {dict} : Hyperparameters of the optimizer.

Source code in src/quast_decisiontree/nodes/optimizer.py 
 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
class OptimizerSetupNode(Node):
    """Sets the hyperparameters of the optimizer.

    Modifications at runtime:
    - hyperparam_values:
        - {dict} : Hyperparameters of the optimizer.
    """

    _known_children = ["SelectBackendNode"]
    _path_keys = dict(hyperparam_values=PathKey(dict))

    def __init__(self, children: list) -> None:
        super().__init__(requires="optimizer_type", creates="optimizer", children=children)
        self._builder = None
        self._hyperparameters = None
        self._queries = None
        self.bound_hp = []

        self.confirm_query = MultiChoiceQuery(
            question="Confirm hyperparameter selection (yes) or restart selection (no):",
            answers=dict(yes="confirm", no="restart"),
            default="yes",
        )

    @property
    def builder(self):
        return self._builder

    @builder.setter
    def builder(self, value: opt.OptimizerBuilder):
        self._builder = value
        self._hyperparameters = None
        self._queries = None

    @property
    def hyperparameters(self):
        if self._builder is not None and self._hyperparameters is None:
            self._hyperparameters = self._builder.hyperparameters
        return self._hyperparameters

    @property
    def queries(self):
        if self.hyperparameters is not None and self._queries is None:
            self._queries = QueryTree(
                queries=[
                    HyperParamQuery(hp)
                    for hp in self.hyperparameters
                    if hp.name not in self.bound_hp
                ]
            )
        return self._queries

    def execute(self, problem_data: dict, path_info: dict) -> dict:
        self.builder = opt_builders[problem_data["optimizer_type"]]
        hyperparam_values = path_info.get("hyperparam_values")
        if hyperparam_values is None:
            confirm = "no"
            while confirm == "no":
                hyperparam_values = self.queries.input()
                self.builder.set_hyperparams(hyperparam_values)
                self.builder.print_hyperparams()
                confirm = self.confirm_query.input()
            path_info["hyperparam_values"] = hyperparam_values
        problem_data["optimizer"] = self.builder.build(hyperparams=hyperparam_values)

        return dict(optimizer_created=True)

bound_hp instance-attribute 

bound_hp = []

confirm_query instance-attribute 

confirm_query = MultiChoiceQuery(
    question="Confirm hyperparameter selection (yes) or restart selection (no):",
    answers=dict(yes="confirm", no="restart"),
    default="yes",
)

builder property writable 

builder

hyperparameters property 

hyperparameters

queries property 

queries

__init__ 

__init__(children)
Source code in src/quast_decisiontree/nodes/optimizer.py 
58
59
60
61
62
63
64
65
66
67
68
69
def __init__(self, children: list) -> None:
    super().__init__(requires="optimizer_type", creates="optimizer", children=children)
    self._builder = None
    self._hyperparameters = None
    self._queries = None
    self.bound_hp = []

    self.confirm_query = MultiChoiceQuery(
        question="Confirm hyperparameter selection (yes) or restart selection (no):",
        answers=dict(yes="confirm", no="restart"),
        default="yes",
    )

execute 

execute(problem_data, path_info)
Source code in src/quast_decisiontree/nodes/optimizer.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
def execute(self, problem_data: dict, path_info: dict) -> dict:
    self.builder = opt_builders[problem_data["optimizer_type"]]
    hyperparam_values = path_info.get("hyperparam_values")
    if hyperparam_values is None:
        confirm = "no"
        while confirm == "no":
            hyperparam_values = self.queries.input()
            self.builder.set_hyperparams(hyperparam_values)
            self.builder.print_hyperparams()
            confirm = self.confirm_query.input()
        path_info["hyperparam_values"] = hyperparam_values
    problem_data["optimizer"] = self.builder.build(hyperparams=hyperparam_values)

    return dict(optimizer_created=True)