iwopy 0.1.5__py3-none-any.whl → 0.1.9__py3-none-any.whl

iwopy/VERSION

@@ -1 +1 @@
-0.1.5
+0.1.9

iwopy/__init__.py

@@ -13,6 +13,11 @@ from . import interfaces
 from . import benchmarks
 from . import optimizers
 
-from importlib.resources import read_text
+try:
+    from importlib.resources import files
 
-__version__ = read_text(__package__, "VERSION")
+    __version__ = files(__package__).joinpath("VERSION").read_text()
+except ImportError:
+    from importlib.resources import read_text
+
+    __version__ = read_text(__package__, "VERSION")

iwopy/benchmarks/branin.py

@@ -7,7 +7,7 @@ class BraninObjective(SimpleObjective):
     """
     The objective function for the Branin problem.
 
-    The Branin, or Branin-Hoo function is defined as
+    The Branin (or Branin-Hoo) function is defined as
 
     f(x,y) = a(y-bx^2+cx-r)^2 + s(1-t)cos(x)+s
 

iwopy/core/optimizer.py

@@ -12,19 +12,22 @@ class Optimizer(Base, metaclass=ABCMeta):
     ----------
     problem: iwopy.Problem
         The problem to optimize
-    name: str, optional
+    name: str
         The name
 
     Attributes
     ----------
     problem: iwopy.Problem
         The problem to optimize
+    name: str
+        The name
 
     """
 
-    def __init__(self, problem, name=None):
+    def __init__(self, problem, name="optimizer"):
         super().__init__(name)
         self.problem = problem
+        self.name = name
 
     def print_info(self):
         """
@@ -81,7 +84,10 @@ class Optimizer(Base, metaclass=ABCMeta):
         if verbosity:
 
             print(f"{type(self).__name__}: Optimization run finished")
-            if isinstance(opt_results.success, bool) or len(opt_results.success.flat) == 1:
+            if (
+                isinstance(opt_results.success, bool)
+                or len(opt_results.success.flat) == 1
+            ):
                 print(f"  Success: {opt_results.success}")
             else:
                 v = np.sum(opt_results.success) / len(opt_results.success.flat)

iwopy/core/problem.py

@@ -709,7 +709,7 @@ class Problem(Base, metaclass=ABCMeta):
         """
         return None
 
-    def evaluate_individual(self, vars_int, vars_float):
+    def evaluate_individual(self, vars_int, vars_float, ret_prob_res=False):
         """
         Evaluate a single individual of the problem.
 
@@ -728,10 +728,12 @@ class Problem(Base, metaclass=ABCMeta):
             The objective function values, shape: (n_objectives,)
         con : np.array
             The constraints values, shape: (n_constraints,)
+        prob_res : object, optional
+            The problem results
 
         """
         objs, cons = None, None
-        if self.memory is not None:
+        if not ret_prob_res and self.memory is not None:
             memres = self.memory.lookup_individual(vars_int, vars_float)
             if memres is not None:
                 objs, cons = memres
@@ -750,9 +752,12 @@ class Problem(Base, metaclass=ABCMeta):
             if self.memory is not None:
                 self.memory.store_individual(vars_int, vars_float, objs, cons)
 
-        return objs, cons
+        if ret_prob_res:
+            return objs, cons, results
+        else:
+            return objs, cons
 
-    def evaluate_population(self, vars_int, vars_float):
+    def evaluate_population(self, vars_int, vars_float, ret_prob_res=False):
         """
         Evaluate all individuals of a population.
 
@@ -762,6 +767,8 @@ class Problem(Base, metaclass=ABCMeta):
             The integer variable values, shape: (n_pop, n_vars_int)
         vars_float : np.array
             The float variable values, shape: (n_pop, n_vars_float)
+        ret_prob_res : bool
+            Flag for additionally returning of problem results
 
         Returns
         -------
@@ -769,11 +776,13 @@ class Problem(Base, metaclass=ABCMeta):
             The objective function values, shape: (n_pop, n_objectives)
         cons : np.array
             The constraints values, shape: (n_pop, n_constraints)
+        prob_res : object, optional
+            The problem results
 
         """
 
         from_mem = False
-        if self.memory is not None:
+        if not ret_prob_res and self.memory is not None:
             memres = self.memory.lookup_population(vars_int, vars_float)
             if memres is not None:
                 todo = np.any(np.isnan(memres), axis=1)
@@ -814,7 +823,10 @@ class Problem(Base, metaclass=ABCMeta):
             if self.memory is not None:
                 self.memory.store_population(vars_int, vars_float, objs, cons)
 
-        return objs, cons
+        if ret_prob_res:
+            return objs, cons, results
+        else:
+            return objs, cons
 
     def check_constraints_individual(self, constraint_values, verbosity=0):
         """
@@ -945,6 +957,54 @@ class Problem(Base, metaclass=ABCMeta):
 
         return results, objs, cons
 
+    def prob_res_einsum_individual(self, prob_res_list, coeffs):
+        """
+        Calculate the einsum of problem results
+
+        Parameters
+        ----------
+        prob_res_list : list
+            The problem results
+        coeffs : numpy.ndarray
+            The coefficients
+
+        Returns
+        -------
+        prob_res : object
+            The weighted sum of problem results
+
+        """
+        if not len(prob_res_list) or prob_res_list[0] is None:
+            return None
+
+        raise NotImplementedError(
+            f"Problem '{self.name}': Einsum not implemented for problem results type '{type(prob_res_list[0]).__name__}'"
+        )
+
+    def prob_res_einsum_population(self, prob_res_list, coeffs):
+        """
+        Calculate the einsum of problem results
+
+        Parameters
+        ----------
+        prob_res_list : list
+            The problem results
+        coeffs : numpy.ndarray
+            The coefficients
+
+        Returns
+        -------
+        prob_res : object
+            The weighted sum of problem results
+
+        """
+        if not len(prob_res_list) or prob_res_list[0] is None:
+            return None
+
+        raise NotImplementedError(
+            f"Problem '{self.name}': Einsum not implemented for problem results type '{type(prob_res_list[0]).__name__}'"
+        )
+
 
 class ProblemDefaultFunc(OptFunctionList):
     """

iwopy/interfaces/__init__.py

@@ -1,2 +1,3 @@
 from . import pygmo
 from . import pymoo
+from . import scipy

iwopy/interfaces/pygmo/algos.py

@@ -1,4 +1,4 @@
-from .imports import pygmo, check_import
+from . import imports
 
 
 class AlgoFactory:
@@ -22,17 +22,17 @@ class AlgoFactory:
 
         Returns
         -------
-        pygmo.algo :
+        imports.pygmo.algo :
             The pygmo algorithm object
 
         """
 
-        check_import()
+        imports.load()
 
         def set_bfe(uda):
             if pop:
                 try:
-                    bfe = pygmo.bfe()
+                    bfe = imports.pygmo.bfe()
                     uda.set_bfe(bfe)
                 except AttributeError:
                     print(
@@ -42,28 +42,28 @@ class AlgoFactory:
         # nlopt:
         if type == "nlopt":
 
-            uda = pygmo.nlopt(kwargs["optimizer"])
+            uda = imports.pygmo.nlopt(kwargs["optimizer"])
             set_bfe(uda)
 
-            algo = pygmo.algorithm(uda)
+            algo = imports.pygmo.algorithm(uda)
 
             if "ftol_rel" in kwargs:
-                algo.extract(pygmo.nlopt).ftol_rel = kwargs["ftol_rel"]
+                algo.extract(imports.pygmo.nlopt).ftol_rel = kwargs["ftol_rel"]
             if "ftol_abs" in kwargs:
-                algo.extract(pygmo.nlopt).ftol_abs = kwargs["ftol_abs"]
+                algo.extract(imports.pygmo.nlopt).ftol_abs = kwargs["ftol_abs"]
             if "xtol_rel" in kwargs:
-                algo.extract(pygmo.nlopt).xtol_rel = kwargs["xtol_rel"]
+                algo.extract(imports.pygmo.nlopt).xtol_rel = kwargs["xtol_rel"]
             if "xtol_abs" in kwargs:
-                algo.extract(pygmo.nlopt).xtol_abs = kwargs["xtol_abs"]
+                algo.extract(imports.pygmo.nlopt).xtol_abs = kwargs["xtol_abs"]
             if "maxeval" in kwargs:
-                algo.extract(pygmo.nlopt).maxeval = kwargs["maxeval"]
+                algo.extract(imports.pygmo.nlopt).maxeval = kwargs["maxeval"]
             if "maxtime" in kwargs:
-                algo.extract(pygmo.nlopt).maxtime = kwargs["maxtime"]
+                algo.extract(imports.pygmo.nlopt).maxtime = kwargs["maxtime"]
 
         # ipopt:
         elif type == "ipopt":
 
-            uda = pygmo.ipopt()
+            uda = imports.pygmo.ipopt()
             set_bfe(uda)
 
             for k, a in kwargs.items():
@@ -77,7 +77,7 @@ class AlgoFactory:
                 else:
                     uda.set_string_option(k, a)
 
-            algo = pygmo.algorithm(uda)
+            algo = imports.pygmo.algorithm(uda)
 
         # sga:
         elif type == "sga":
@@ -109,10 +109,10 @@ class AlgoFactory:
                 *Crossover*: four different crossover schemes are provided:``single``, ``exponential``, ``binomial``, ``sbx``. The
                 ``single`` point crossover, works selecting a random point in the parent chromosome and, with probability *cr*, inserting the
                 partner chromosome thereafter. The ``exponential`` crossover is taken from the algorithm differential evolution,
-                implemented, in pygmo, as :class:`~pygmo.de`. It essentially selects a random point in the parent chromosome and inserts,
+                implemented, in pygmo, as :class:`~imports.pygmo.de`. It essentially selects a random point in the parent chromosome and inserts,
                 in each successive gene, the partner values with probability  *cr* up to when it stops. The binomial crossover
                 inserts each gene from the partner with probability *cr*. The simulated binary crossover (called ``sbx``), is taken
-                from the NSGA-II algorithm, implemented in pygmo as :class:`~pygmo.nsga2`, and makes use of an additional parameter called
+                from the NSGA-II algorithm, implemented in pygmo as :class:`~imports.pygmo.nsga2`, and makes use of an additional parameter called
                 distribution index *eta_c*.
 
                 *Mutation*: three different mutations schemes are provided: ``uniform``, ``gaussian`` and ``polynomial``. Uniform mutation
@@ -125,10 +125,10 @@ class AlgoFactory:
 
             """
 
-            uda = pygmo.sga(**kwargs)
+            uda = imports.pygmo.sga(**kwargs)
             set_bfe(uda)
 
-            algo = pygmo.algorithm(uda)
+            algo = imports.pygmo.algorithm(uda)
 
         # pso:
         elif type == "pso":
@@ -171,10 +171,10 @@ class AlgoFactory:
 
             """
 
-            uda = pygmo.pso(**kwargs)
+            uda = imports.pygmo.pso(**kwargs)
             set_bfe(uda)
 
-            algo = pygmo.algorithm(uda)
+            algo = imports.pygmo.algorithm(uda)
 
         # bee_colony:
         elif type == "bee_colony":
@@ -193,10 +193,10 @@ class AlgoFactory:
 
             """
 
-            uda = pygmo.bee_colony(**kwargs)
+            uda = imports.pygmo.bee_colony(**kwargs)
             set_bfe(uda)
 
-            algo = pygmo.algorithm(uda)
+            algo = imports.pygmo.algorithm(uda)
 
         # nsga2:
         elif type == "nsga2":
@@ -219,10 +219,10 @@ class AlgoFactory:
 
             """
 
-            uda = pygmo.nsga2(**kwargs)
+            uda = imports.pygmo.nsga2(**kwargs)
             set_bfe(uda)
 
-            algo = pygmo.algorithm(uda)
+            algo = imports.pygmo.algorithm(uda)
 
         # unknown driver:
         else:

iwopy/interfaces/pygmo/imports.py

@@ -1,20 +1,21 @@
-try:
-    import pygmo
-
-    IMPORT_OK = True
-except ImportError:
-    pygmo = None
-    IMPORT_OK = False
-
-
-def check_import():
-    """
-    Checks if library import worked,
-    raises error otherwise.
-    """
-    if not IMPORT_OK:
-        print("\n\nFailed to import pygmo. Please install, either via pip:\n")
-        print("  pip install pygmo\n")
-        print("or via conda:\n")
-        print("  conda install -c conda-forge pygmo\n")
-        raise ImportError("Failed to import pygmo")
+from iwopy.utils import import_module
+
+pygmo = None
+loaded = False
+
+
+def load(verbosity=1):
+
+    global pygmo, loaded
+
+    if not loaded:
+
+        if verbosity:
+            print("Loading pygmo")
+
+        pygmo = import_module("pygmo", hint="pip install pygmo")
+
+        loaded = True
+
+        if verbosity:
+            print("pygmo successfully loaded")

iwopy/interfaces/pygmo/optimizer.py

@@ -4,7 +4,7 @@ from iwopy.core import Optimizer
 from iwopy.utils import suppress_stdout
 from .problem import UDP
 from .algos import AlgoFactory
-from .imports import pygmo, check_import
+from . import imports
 
 
 class Optimizer_pygmo(Optimizer):
@@ -31,9 +31,9 @@ class Optimizer_pygmo(Optimizer):
         Parameters for the alorithm
     setup_pars : dict
         Parameters for the calculation setup
-    udp : iwopy.interfaces.pygmo.UDA
+    udp : iwopy.interfaces.imports.pygmo.UDA
         The pygmo problem
-    algo : pygmo.algo
+    algo : imports.pygmo.algo
         The pygmo algorithm
 
     """
@@ -41,7 +41,7 @@ class Optimizer_pygmo(Optimizer):
     def __init__(self, problem, problem_pars, algo_pars, setup_pars={}):
         super().__init__(problem)
 
-        check_import()
+        imports.load()
 
         self.problem_pars = problem_pars
         self.algo_pars = algo_pars
@@ -72,7 +72,7 @@ class Optimizer_pygmo(Optimizer):
         psize = self.setup_pars.get("pop_size", 1)
         pseed = self.setup_pars.get("seed", None)
         pnrfi = self.setup_pars.get("norandom_first", psize == 1)
-        self.pop = pygmo.population(self.udp, size=psize, seed=pseed)
+        self.pop = imports.pygmo.population(self.udp, size=psize, seed=pseed)
         self.pop.problem.c_tol = [
             self.setup_pars.get("c_tol", 1e-4)
         ] * self.pop.problem.get_nc()

iwopy/interfaces/pymoo/__init__.py

@@ -1 +1 @@
-from .optimizer import Optimizer_pymoo, DefaultCallback
+from .optimizer import Optimizer_pymoo

iwopy/interfaces/pymoo/factory.py

@@ -1,23 +1,4 @@
-from .imports import IMPORT_OK, check_import
-
-if IMPORT_OK:
-    from pymoo.operators.sampling.rnd import (
-        IntegerRandomSampling,
-        FloatRandomSampling,
-        BinaryRandomSampling,
-        PermutationRandomSampling,
-    )
-    from pymoo.operators.sampling.lhs import LatinHypercubeSampling
-    from pymoo.operators.crossover.sbx import SBX
-    from pymoo.operators.mutation.pm import PM
-    from pymoo.algorithms.soo.nonconvex.ga import GA
-    from pymoo.algorithms.moo.nsga2 import NSGA2
-    from pymoo.algorithms.soo.nonconvex.pso import PSO
-    from pymoo.core.mixed import MixedVariableGA
-    from pymoo.termination.default import (
-        DefaultSingleObjectiveTermination,
-        DefaultMultiObjectiveTermination,
-    )
+from . import imports
 
 
 class Factory:
@@ -26,10 +7,11 @@ class Factory:
     """
 
     def __init__(self, pymoo_problem, verbosity):
-        check_import()
         self.pymoo_problem = pymoo_problem
         self.verbosity = verbosity
 
+        imports.load(verbosity)
+
     def print(self, *args, **kwargs):
         if self.verbosity:
             print(*args, **kwargs)
@@ -45,15 +27,15 @@ class Factory:
                 samp_name = "float_random"
 
         if samp_name == "int_random":
-            out = IntegerRandomSampling(**kwargs)
+            out = imports.IntegerRandomSampling(**kwargs)
         elif samp_name == "float_random":
-            out = FloatRandomSampling(**kwargs)
+            out = imports.FloatRandomSampling(**kwargs)
         elif samp_name == "binary_random":
-            out = BinaryRandomSampling(**kwargs)
+            out = imports.BinaryRandomSampling(**kwargs)
         elif samp_name == "permutation_random":
-            out = PermutationRandomSampling(**kwargs)
+            out = imports.PermutationRandomSampling(**kwargs)
         elif samp_name == "lhs":
-            out = LatinHypercubeSampling(**kwargs)
+            out = imports.LatinHypercubeSampling(**kwargs)
         else:
             raise KeyError(
                 f"Unknown sampling '{samp_name}', please choose: int_random, float_random, binary_random, permutation_random, lhs"
@@ -68,7 +50,7 @@ class Factory:
         Crossover factory function
         """
         if cross == "sbx":
-            out = SBX(**pars)
+            out = imports.SBX(**pars)
         else:
             raise KeyError(f"Unknown crossover '{cross}', please choose: sbx")
 
@@ -81,7 +63,7 @@ class Factory:
         Mutation factory function
         """
         if mut == "pm":
-            out = PM(**pars)
+            out = imports.PM(**pars)
         else:
             raise KeyError(f"Unknown mutation '{mut}', please choose: pm")
 
@@ -118,7 +100,7 @@ class Factory:
                 mut = pars["mutation"]
                 pars["mutation"] = self.get_mutation(mut, **mut_pars)
 
-            out = GA(**pars)
+            out = imports.GA(**pars)
 
         # Particle Swarm:
         elif typ == "PSO":
@@ -144,7 +126,7 @@ class Factory:
                 mut = pars["mutation"]
                 pars["mutation"] = self.get_mutation(mut, **mut_pars)
 
-            out = PSO(**pars)
+            out = imports.PSO(**pars)
 
         # NSGA2:
         elif typ == "NSGA2":
@@ -169,7 +151,7 @@ class Factory:
                 mut = pars["mutation"]
                 pars["mutation"] = self.get_mutation(mut, **mut_pars)
 
-            out = NSGA2(**pars)
+            out = imports.NSGA2(**pars)
 
         # MixedVariableGA:
         elif typ == "MixedVariableGA":
@@ -188,10 +170,12 @@ class Factory:
                 mut = pars["mutation"]
                 pars["mutation"] = self.get_mutation(mut, **mut_pars)
 
-            out = MixedVariableGA(**pars)
+            out = imports.MixedVariableGA(**pars)
 
         else:
-            raise KeyError(f"Unknown algorithm '{typ}', please choose: GA, PSO, NSGA2, MixedVariableGA")
+            raise KeyError(
+                f"Unknown algorithm '{typ}', please choose: GA, PSO, NSGA2, MixedVariableGA"
+            )
 
         self.print(f"Selecting algorithm: {typ} ({type(out).__name__})")
 
@@ -210,9 +194,9 @@ class Factory:
             return typ
         elif typ == "default":
             if self.pymoo_problem.problem.n_objectives > 1:
-                out = DefaultMultiObjectiveTermination(**term_pars)
+                out = imports.DefaultMultiObjectiveTermination(**term_pars)
             else:
-                out = DefaultSingleObjectiveTermination(**term_pars)
+                out = imports.DefaultSingleObjectiveTermination(**term_pars)
         else:
             raise KeyError(f"Unknown termination '{type}', please choose: default")
 

iwopy/interfaces/pymoo/imports.py

@@ -1,30 +1,83 @@
-try:
+from iwopy.utils import import_module
 
-    from pymoo.core.callback import Callback
-    from pymoo.core.problem import Problem
-    from pymoo.core.variable import Real, Integer
+Callback = None
+Problem = None
+Real = None
+Integer = None
 
-    IMPORT_OK = True
+IntegerRandomSampling = None
+FloatRandomSampling = None
+BinaryRandomSampling = None
+PermutationRandomSampling = None
 
-except ImportError:
+LatinHypercubeSampling = None
+SBX = None
+PM = None
+GA = None
+NSGA2 = None
+PSO = None
+MixedVariableGA = None
 
-    Problem = object
+DefaultSingleObjectiveTermination = None
+DefaultMultiObjectiveTermination = None
 
-    class Callback:
-        def __init__(self):
-            self.data = dict()
+minimize = None
 
-    IMPORT_OK = False
+loaded = False
 
 
-def check_import():
-    """
-    Checks if library import worked,
-    raises error otherwise.
-    """
-    if not IMPORT_OK:
-        print("\n\nFailed to import pmoo. Please install, either via pip:\n")
-        print("  pip install pymoo\n")
-        print("or via conda:\n")
-        print("  conda install -c conda-forge pymoo\n")
-        raise ImportError("Failed to import pymoo")
+def load(verbosity=1):
+
+    global Callback, Problem, Real, Integer, IntegerRandomSampling, FloatRandomSampling
+    global BinaryRandomSampling, PermutationRandomSampling, LatinHypercubeSampling, SBX
+    global PM, GA, NSGA2, PSO, MixedVariableGA, DefaultSingleObjectiveTermination
+    global DefaultMultiObjectiveTermination, minimize, loaded
+
+    if not loaded:
+
+        if verbosity:
+            print("Loading pymoo")
+
+        Callback = import_module(
+            "pymoo.core.callback", hint="pip install pymoo"
+        ).Callback
+        Problem = import_module("pymoo.core.problem", hint="pip install pymoo").Problem
+        Real = import_module("pymoo.core.variable", hint="pip install pymoo").Real
+        Integer = import_module("pymoo.core.variable", hint="pip install pymoo").Integer
+
+        rnd = import_module("pymoo.operators.sampling.rnd", hint="pip install pymoo")
+        IntegerRandomSampling = rnd.IntegerRandomSampling
+        FloatRandomSampling = rnd.FloatRandomSampling
+        BinaryRandomSampling = rnd.BinaryRandomSampling
+        PermutationRandomSampling = rnd.PermutationRandomSampling
+
+        LatinHypercubeSampling = import_module(
+            "pymoo.operators.sampling.lhs", hint="pip install pymoo"
+        ).LatinHypercubeSampling
+        SBX = import_module(
+            "pymoo.operators.crossover.sbx", hint="pip install pymoo"
+        ).SBX
+        PM = import_module("pymoo.operators.mutation.pm", hint="pip install pymoo").PM
+        GA = import_module(
+            "pymoo.algorithms.soo.nonconvex.ga", hint="pip install pymoo"
+        ).GA
+        NSGA2 = import_module(
+            "pymoo.algorithms.moo.nsga2", hint="pip install pymoo"
+        ).NSGA2
+        PSO = import_module(
+            "pymoo.algorithms.soo.nonconvex.pso", hint="pip install pymoo"
+        ).PSO
+        MixedVariableGA = import_module(
+            "pymoo.core.mixed", hint="pip install pymoo"
+        ).MixedVariableGA
+
+        ter = import_module("pymoo.termination.default", hint="pip install pymoo")
+        DefaultSingleObjectiveTermination = ter.DefaultSingleObjectiveTermination
+        DefaultMultiObjectiveTermination = ter.DefaultMultiObjectiveTermination
+
+        minimize = import_module("pymoo.optimize", hint="pip install pymoo").minimize
+
+        loaded = True
+
+        if verbosity:
+            print("pymoo successfully loaded")