Progresively interactive NSGA-II

docs/source/algorithms/algorithms.csv

@@ -9,6 +9,7 @@
    :ref:`Improved Stochastic Ranking Evolutionary Strategy <nb_isres>`, ISRES, single, x, An improved version of SRES being able to deal dependent variables efficiently.
    :ref:`NSGA-II <nb_nsga2>`, NSGA2, multi, x, Well-known multi-objective optimization algorithm based on non-dominated sorting and crowding.
    :ref:`R-NSGA-II <nb_rnsga2>`, RNSGA2, multi, x, An extension of NSGA-II where reference/aspiration points can be provided by the user.
+   :ref:`PI-NSGA-II <nb_pinsga2>`, PINSGA2, multi, x, An interactive version of NSGA-II that uses user preference to guide the optimization towards desired solutions.
    :ref:`NSGA-III <nb_nsga3>`, NSGA3, many, x, An improvement of NSGA-II developed for multi-objective optimization problems with more than two objectives.
    :ref:`U-NSGA-III <nb_unsga3>`, UNSGA3, many, x, A generalization of NSGA-III to be more efficient for single and bi-objective optimization problems.
    :ref:`R-NSGA-III <nb_rnsga3>`, RNSGA3, many, x, Allows defining aspiration points for NSGA-III to incorporate the user's preference.

docs/source/references.bib

@@ -754,3 +754,16 @@ @article{mosade
   year={2010},
   publisher={Springer}
 }
+
+
+
+@article{piemovf,
+  title={An interactive evolutionary multiobjective optimization method based on progressively approximated value functions},
+  author={Deb, Kalyanmoy and Sinha, Ankur and Korhonen, Pekka J and Wallenius, Jyrki},
+  journal={IEEE Transactions on Evolutionary Computation},
+  volume={14},
+  number={5},
+  pages={723--739},
+  year={2010},
+  publisher={IEEE}
+}

examples/algorithms/moo/pinsga2.py

@@ -0,0 +1,90 @@
+from pymoo.algorithms.moo.pinsga2 import PINSGA2
+from pymoo.optimize import minimize
+from pymoo.problems.multi import ZDT1
+from pymoo.problems.multi import ZDT3
+import pymoo.gradient.toolbox as anp
+import matplotlib.pyplot as plt
+from pymoo.visualization.scatter import Scatter
+from pymoo.util import value_functions as mvf
+
+
+# Additional example from original PI-EMO-VF literature
+class ZDT1_max(ZDT1):
+
+    def _evaluate(self, x, out, *args, **kwargs): 
+        f1 = x[:, 0]
+        g = 1 + 9.0 / (self.n_var - 1) * anp.sum(x[:, 1:], axis=1)
+        f2 = (10 - anp.power((f1 * g), 0.5)) / g
+
+        f1 = -1 * f1;
+        f2 = -1 * f2;
+
+        out["F"] = anp.column_stack([f1, f2])
+
+
+
+def plot_eta_F(context, algorithm):
+
+
+    # Next highlight the eta selctions
+    if len(algorithm.eta_F) > 0:
+
+        # Plot the historical PO fronts
+        plot = Scatter().add(algorithm.historical_F, facecolors= '#f5f5f5', edgecolors='#f5f5f5')
+
+        # The current PO front 
+        plot.add(algorithm.paused_F)
+
+        # Starred items for the DM
+        plot.add(algorithm.eta_F, s=500, marker='*', facecolors='red')
+
+
+    else: 
+        F = algorithm.pop.get("F")
+        plot = Scatter().add(F)
+
+
+    plot.plot_if_not_done_yet()
+
+    return plot.fig
+
+
+def plot_vf(context, algorithm):
+
+    # This option prevents us from plotting vf every single 
+    if not algorithm.vf_plot_flag and algorithm.vf_plot: 
+        return algorithm.vf_plot
+
+    # This option is if a vf has been calculated and we want to plot it
+    elif len(algorithm.eta_F) > 0 and (algorithm.vf_res is not None) and algorithm.vf_plot_flag:
+        plot = mvf.plot_vf(algorithm.eta_F * -1, algorithm.vf_res.vf, show=False)
+
+        algorithm.vf_plot_flag = False;
+
+        algorithm.vf_plot = plot.gcf()
+
+        return plot.gcf()
+
+    # This option is if we have not calculated a vf and we just want to show the PF
+    else: 
+        F = algorithm.pop.get("F")
+
+        plt.scatter(F[:, 0], F[:, 1], color='blue')
+
+        algorithm.vf_plot = plt.gcf()
+
+        return algorithm.vf_plot
+
+
+problem = ZDT3()
+
+# opt_method can be trust-constr, SLSQP, ES, or GA
+# vf_type can be linear or poly
+algorithm = PINSGA2(pop_size=30, opt_method="trust-constr", vf_type="poly")
+
+res = minimize(problem,
+               algorithm,
+               ('n_gen', 200),
+               seed=1,
+               verbose=True)
+

examples/misc/value_functions.py

@@ -0,0 +1,70 @@
+from pymoo.util import value_functions as mvf
+import numpy as np
+
+## Examples from Sinha's code
+P = np.array([[3.6, 3.9], 
+              [2.5, 4.1],    
+              [5.5, 2.5],      
+              [0.5, 5.2],     
+              [6.9, 1.8]])
+ranks = [1,2,2,3,4]
+#ranks = [1,4,3,5,2]
+
+# This is a great example. Illustrates the when polynomial versus linear works 
+# when the problem is changed from. 
+# TODO Also doesn't work for scimin minimization. It does that weird thing where
+# multiple lines are drawn on the contour
+#P = np.array([[1, 5],
+#              [2, 3],
+#              [3, 2],
+#              [4, 1]])
+#
+#ranks = [3,4,2,1]
+
+
+#P = np.array([[4, 4], 
+#              [4, 3], 
+#              [2, 4], 
+#              [4, 1], 
+#              [1, 3]]);
+#
+#ranks = [1,2,3,4,5]
+
+
+# Partial ordering example
+P = np.array([[3.6, 3.9], [2.5, 4.1], [5.5, 2.5], [0.5, 5.2], [6.9, 1.8]])
+
+ranks = [1, 2, 3, 3, 4]
+
+# opt_method can be trust-constr, SLSQP, ES, or GA
+opt_method = "trust-constr"
+
+# linear or poly
+fnc_type = "poly"
+
+
+if fnc_type == "linear":
+
+    vf_res = mvf.create_linear_vf(P, ranks, method=opt_method)
+
+elif fnc_type == "poly": 
+
+    vf_res = mvf.create_poly_vf(P, ranks, method=opt_method)
+
+else: 
+
+    print("function not supported")
+
+if vf_res.fit:
+
+    print("Final parameters:")
+    print(vf_res.params)
+
+    print("Final epsilon:")
+    print(vf_res.epsilon)
+
+    mvf.plot_vf(P, vf_res.vf)
+
+
+
+