add different complexity measures to glyph-remote

Author: Ohjeah

glyph/assessment.py

@@ -250,3 +250,16 @@ def inner(*args, **kwargs):
             return timeoutable(default=max_fitness)(f)(*args, timeout=timeout, **kwargs)
         return inner
     return decorate
+
+
+def expressional_complexity(ind):
+    """Sum of length of all subtrees of the individual."""
+    return sum(len(ind[ind.searchSubtree(i)]) for i in range(len(ind)))
+
+
+complexity_measures = {
+    "ec_genotype": expressional_complexity,
+    "ec_phenotype": lambda ind: expressional_complexity(ind.resolve_sc()),
+    "num_nodes_genotype": len,
+    "num_nodes_phenotype": lambda ind: len(ind.resolve_sc())
+}

glyph/cli/_parser.py

@@ -5,6 +5,7 @@
 import numpy as np
 
 import glyph.application
+import glyph.assessment
 from glyph.utils.argparse import (
     catch_and_log,
     positive_int,
@@ -137,11 +138,10 @@ def get_parser(parser=None):
     parser.add_argument(
         "--send_meta_data", action="store_true", default=False, help="Send metadata after each generation"
     )
-    # Gooey has a bug when using the action 'count'.
-    # To work as expected the '-' flag has to be first and the '--' flag has to be second.
     parser.add_argument(
         "-v",
         "--verbose",
+        type=str.upper,
         dest="verbosity",
         choices=["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG", "NOTSET"],
         default="INFO",
@@ -221,10 +221,10 @@ def get_parser(parser=None):
         help="Simplify expression before sending them. (default: False)",
     )
     ass_group.add_argument(
-        "--consider_complexity",
-        action="store_false",
-        default=True,
-        help="Consider the complexity of solutions for MOO (default: True)",
+        "--complexity_measure",
+        choices=["None"] + list(glyph.assessment.complexity_measures.keys()),
+        default=None,
+        help="Consider the complexity of solutions for MOO (default: None)",
     )
     ass_group.add_argument(
         "--no_caching",
@@ -353,7 +353,6 @@ def get_parser(parser=None):
     constraints = parser.add_argument_group("constraints")
     glyph.application.ConstraintsFactory.add_options(constraints)
 
-
     observer = parser.add_argument_group("observer")
     observer.add_argument(
         "--animate",

glyph/cli/glyph_remote.py

@@ -17,18 +17,18 @@
 
 import deap.gp
 import deap.tools
-from deprecated import deprecated
-import glyph.application
-import glyph.gp.individual
-import glyph.utils
 import sympy
 import zmq
+from deprecated import deprecated
 from cache import DBCache
 from scipy.optimize._minimize import _minimize_neldermead as nelder_mead
 
 
+import glyph.application
+import glyph.gp.individual
+import glyph.utils
 from glyph._version import get_versions
-from glyph.assessment import const_opt
+from glyph.assessment import const_opt, complexity_measures
 from glyph.cli._parser import *  # noqa
 from glyph.gp.constraints import constrain
 from glyph.gp.individual import _constant_normal_form, add_sc, pretty_print, sc_mmqout, simplify_this
@@ -39,7 +39,11 @@
 from glyph.utils.logging import print_params, load_config
 
 logger = logging.getLogger(__name__)
-version = get_versions()["version"]
+
+
+def get_version_info():
+    version = get_versions()["version"]
+    return f"Version {version}"
 
 
 class ExperimentProtocol(enum.EnumMeta):
@@ -100,7 +104,7 @@ def from_checkpoint(cls, file_name, com):
         gp_runner = cp["runner"]
         gp_runner.assessment_runner = RemoteAssessmentRunner(
             com,
-            consider_complexity=args.consider_complexity,
+            complexity_measure=args.complexity_measure,
             method=args.const_opt_method,
             options=args.options,
             caching=args.caching,
@@ -264,7 +268,7 @@ class RemoteAssessmentRunner:
     def __init__(
         self,
         com,
-        consider_complexity=True,
+        complexity_measure=None,
         multi_objective=False,
         method="Nelder-Mead",
         options={"smart_options": {"use": False}},
@@ -277,7 +281,7 @@ def __init__(
     ):
         """Contains assessment logic. Uses zmq connection to request evaluation."""
         self.com = com
-        self.consider_complexity = consider_complexity
+        self.complexity_measure = complexity_measures.get(complexity_measure, None)
         self.multi_objective = multi_objective
         self.caching = caching
         self.cache = {} if persistent_caching is None else DBCache("glyph-remote", persistent_caching)
@@ -296,7 +300,7 @@ def __init__(
 
             self.smart_options = options.get("smart_options")
             if self.smart_options["use"]:
-                self.method = glyph.utils.numeric.SmartConstantOptimizer(
+                self.method = glyph.utils.numeric.SlowConversionTerminator(
                     glyph.utils.numeric.hill_climb, **self.smart_options["kw"]
                 )
 
@@ -345,8 +349,8 @@ def measure(self, individual, meta=None):
 
         self.queue.put(None)
         individual.popt = popt
-        if self.consider_complexity:
-            fitness = *error, sum(map(len, individual))
+        if self.complexity_measure:
+            fitness = *error, sum(map(self.complexity_measure, individual))
         else:
             fitness = error
         return fitness
@@ -469,7 +473,7 @@ def make_remote_app(callbacks=(), callback_factories=(), parser=None):
             com,
             method=args.const_opt_method,
             options=args.options,
-            consider_complexity=args.consider_complexity,
+            complexity_measure=args.complexity_measure,
             caching=args.caching,
             persistent_caching=args.persistent_caching,
             simplify=args.simplify,
@@ -513,9 +517,13 @@ def make_remote_app(callbacks=(), callback_factories=(), parser=None):
         app = RemoteApp(args, gp_runner, args.checkpoint_file, callbacks=callbacks)
 
     bc = break_condition(ttl=args.ttl, target=args.target, max_iter=args.max_iter_total, error_index=0)
+    return app, bc, args
+
+
+def log_info(args):
+    logger.info(f"Glyph-remote. {get_version_info()}")
     logger.debug("Parameters:")
     print_params(logger.debug, vars(args))
-    return app, bc, args
 
 
 def send_meta_data(app):
@@ -527,8 +535,8 @@ def send_meta_data(app):
 
 
 def main():
-    logger.info(f"Glyph-remote: Version {version}")
     app, bc, args = make_remote_app()
+    log_info(args)
     app.run(break_condition=bc)
 
 

glyph/gp/individual.py

@@ -17,13 +17,6 @@
 
 logger = logging.getLogger(__name__)
 
-#def len_subtree(i):
-#    sl_left = ind.searchSubtree(i+1)
-#    len_left = sl_left.stop - sl_left.start
-#    sl_right = ind.searchSubtree(sl_left.stop)
-#    len_right = sl_right.stop - sl_right.start
-#    return len_left, len_right
-
 
 def sc_qout(x, y):
     """SC is the quotient of the number of nodes of its left and right child-trees x and y"""
@@ -54,25 +47,6 @@ def as_terminal(self, *args):
         return deap.gp.Terminal(self.func(*vals), False, deap.gp.__type__)
 
 
-def resolve_sc(ind):
-    """Evaluate StructConst in individual top to bottom."""
-    nodes = type(ind)(ind[:])
-
-    # structure based constants need to be evaluated top to bottom first
-    is_sc = lambda n: isinstance(n, StructConst)
-    while any(n for n in nodes if is_sc(n)):
-        # get the first structure based constant
-        i, node = next(filter((lambda x: is_sc(x[1])), enumerate(nodes)))
-        slice_ = nodes.searchSubtree(i)
-        # find its subtree
-        subtree = type(ind)(nodes[slice_])
-        # replace the subtree by a Terminal representing its numeric value
-        # child_trees helper function yields a list of tree which are used as arguments by the first primitive
-        args = list(child_trees(subtree))
-        nodes[slice_] = [node.as_terminal(*args)]
-    return nodes
-
-
 def add_sc(pset, func):
     """Adds a structural constant to a given primitive set.
 
@@ -281,9 +255,27 @@ def __repr__(self):
     def __str__(self):
         return self.to_polish()
 
+    def resolve_sc(self):
+        """Evaluate StructConst in individual top to bottom."""
+        nodes = type(self)(self[:])
+
+        # structure based constants need to be evaluated top to bottom first
+        is_sc = lambda n: isinstance(n, StructConst)
+        while any(n for n in nodes if is_sc(n)):
+            # get the first structure based constant
+            i, node = next(filter((lambda x: is_sc(x[1])), enumerate(nodes)))
+            slice_ = nodes.searchSubtree(i)
+            # find its subtree
+            subtree = type(self)(nodes[slice_])
+            # replace the subtree by a Terminal representing its numeric value
+            # child_trees helper function yields a list of tree which are used as arguments by the first primitive
+            args = list(child_trees(subtree))
+            nodes[slice_] = [node.as_terminal(*args)]
+        return nodes
+
     def to_polish(self, for_sympy=False, replace_struct=True):
         """Symbolic representation of the expression tree."""
-        nodes = resolve_sc(self) if replace_struct else self
+        nodes = self.resolve_sc() if replace_struct else self
         repr = ""
         stack = []
         for node in nodes:

glyph/utils/numeric.py

@@ -91,7 +91,7 @@ def f(x):
     return res
 
 
-class SmartConstantOptimizer:
+class SlowConversionTerminator:
     def __init__(self, method, step_size=10, min_stat=10, threshold=25):
         """Decorate a minimize method used in `scipy.optimize.minimize` to cancel non promising constant optimizations.
 
@@ -136,7 +136,3 @@ def __call__(self, fun, x0, args, **kwargs):
 
         return res
 
-
-def expressional_complexity(ind):
-    """Sum of length of all subtrees of the individual."""
-    return sum(len(ind[ind.searchSubtree(i)]) for i in range(len(ind)))

tests/unittest/test_assessment.py

@@ -177,7 +177,6 @@ def test_pickle_assessment_runner():
 
 @pytest.mark.parametrize("x", [[np.nan], np.array([np.nan]), np.nan])
 def test_replace_nan(x):
-    print(x)
     x_clean = assessment.replace_nan(x)
     assert isinstance(x_clean, type(x))
     try:
@@ -217,3 +216,14 @@ def g():
 
     assert decorator(f)() == 1
     assert decorator(g)() == 2
+
+
+ec_cases = (
+    ("x_0", 1),
+    ("Add(exp(x_0), x_0)", 8),
+)
+
+
+@pytest.mark.parametrize("expr, res", ec_cases)
+def test_expressional_complexity(NumpyIndividual, expr, res):
+    assert assessment.expressional_complexity(NumpyIndividual.from_string(expr)) == res

tests/unittest/utils/test_numerics.py

@@ -1,15 +1,3 @@
 import pytest
 
 from glyph.utils.numeric import *
-
-
-ec_cases = (
-    ("x_0", 1),
-    ("Add(exp(x_0), x_0)", 8),
-)
-
-
-@pytest.mark.parametrize("case", ec_cases)
-def test_expressional_complexity(NumpyIndividual, case):
-    expr, res = case
-    assert expressional_complexity(NumpyIndividual.from_string(expr)) == res