Added numpy warning tests

* Added a tree for the LispTreeExpr class and another for
  the whole project #61

Author: Ezetowers

templates/toy_problem.py

@@ -55,13 +55,13 @@ def individual_data(indiv):
 
 def cost(indiv):
     x, y, y2, mlc_y3 = individual_data(indiv)
-    cost_mlc_y3 = None
-    try:
-        cost_mlc_y3 = float(np.sum((mlc_y3 - y2)**2))
-    except FloatingPointError, err:
-        np.seterr(all='ignore')
-        cost_mlc_y3 = float(np.sum((mlc_y3 - y2)**2))
-        np.seterr(all='raise')
+
+    # Deactivate the numpy warnings, because this sum raise an overflow
+    # Runtime warning from time to time
+    np.seterr(all='ignore')
+    cost_mlc_y3 = float(np.sum((mlc_y3 - y2)**2))
+    np.seterr(all='warn')
+
     return cost_mlc_y3
 
 

tests/default_test_configuration.ini

@@ -1,5 +1,5 @@
 [LOGGING]
-logmode = console
+logmode = file
 
 [POPULATION]
 # Population size. This paramater can be a number or a numpy array

tests/mlc/application/__init__.py

@@ -0,0 +1,80 @@
+[LOGGING]
+logmode = file
+
+[POPULATION]
+# Population size. This paramater can be a number or a numpy array
+size = 10
+sensors = 1
+sensor_spec = false
+sensor_list = 1, 9, 4
+controls = 1
+sensor_prob = 0.33
+leaf_prob = 0.3
+range = 10
+precision = 4
+# Numpy arrange
+opsetrange = 1:10
+formal = 1
+end_character =
+individual_type = tree
+
+[GP]
+# GP algortihm (CHANGE IF YOU KNOW WHAT YOU DO)
+maxdepth = 15
+maxdepthfirst = 5
+mindepth = 2
+mutmindepth = 2
+mutmaxdepth = 15
+mutsubtreemindepth = 2
+generation_method = mixed_ramped_gauss
+gaussigma = 3
+# Numpy arange
+ramp = 2:9
+maxtries = 10
+mutation_types = 1:5
+
+[OPTIMIZATION]
+#  Optimization parameters
+elitism = 10
+probrep = 0.1
+probmut = 0.4
+probcro = 0.5
+selectionmethod = tournament
+tournamentsize = 7
+lookforduplicates = true
+simplify = false
+# Numpy array
+cascade = 1,1
+
+[EVALUATOR]
+#  Evaluator
+# evaluation_method = standalone_function
+# evaluation_method = standalone_files
+evaluation_method = mfile_standalone
+evaluation_function = numpy_warnings_ev_script
+indfile = ind.dat
+Jfile = J.dat
+# exchangedir = fullfile(pwd,evaluator0)
+evaluate_all = 0
+ev_again_best = false
+ev_again_nb = 5
+ev_again_times = 5
+artificialnoise = 0
+execute_before_evaluation =
+badvalue = 1e36
+badvalues_elim = first
+%badvalues_elim = none
+%badvalues_elim = all
+preevaluation = false
+preev_function = default
+problem_variables.gamma = 0.1
+
+[BEHAVIOUR]
+## MLC behaviour
+verbose = 2
+fgen = 250
+stopongraph = false
+showeveryitbest = true
+save = false
+saveincomplete = 1
+savedir = test_first_experiment.mlc

tests/mlc/application/numpy_warnings_config.ini

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import MLC.Log.log as lg
+import matplotlib.pyplot as plt
+import sys
+import time
+
+from MLC.mlc_parameters.mlc_parameters import Config
+from PyQt5.QtCore import Qt
+
+
+def individual_data(indiv):
+    x = np.linspace(-10.0, 10.0, num=201)
+    y = np.tanh(x**3 - x**2 - 1)
+
+    # FIXME: Added timeout to visualize
+    # time.sleep(0.5)
+
+    config = Config.get_instance()
+    # artificial_noise = self._config.getint('EVALUATOR', 'artificialnoise')
+
+    # In this test we have no noise by config file. But, if this were the
+    # case, we would a have problem because the random of MATLAB is not
+    # the random of Python :(
+    # WORKAROUND: Generate the noise in matlab and process it in python
+
+    # MAKE SOME NOISE!!!
+    # noise = eng.eval('rand(length(zeros(1, ' + str(len(x)) + ')))-0.5')
+    # np_noise = np.array([s for s in noise[0]])
+    # y2 = y + np_noise * 500 * artificial_noise
+
+    y2 = y
+
+    # Force a numpy warning BEFORE the LispTreeExpr calculation
+    np.cos(np.inf)
+
+    if isinstance(indiv.get_formal(), str):
+        formal = indiv.get_formal().replace('S0', 'x')
+    else:
+        # toy problem support for multiple controls
+        formal = indiv.get_formal()[0].replace('S0', 'x')
+
+    # Calculate J like the sum of the square difference of the
+    # functions in every point
+
+    lg.logger_.debug('[POP][TOY_PROBLEM] Individual Formal: ' + formal)
+    mlc_y3 = indiv.get_tree().calculate_expression([x])
+
+    # If the expression doesn't have the term 'x',
+    # the eval returns a value (float) instead of an array.
+    # In that case transform it to an array
+    if type(mlc_y3) == float:
+        mlc_y3 = np.repeat(mlc_y3, len(x))
+
+    # Force a numpy warning AFTER the LispTreeExpr calculation
+    np.cos(np.inf)
+
+    return x, y, y2, mlc_y3
+
+
+def cost(indiv):
+    x, y, y2, mlc_y3 = individual_data(indiv)
+    cost_mlc_y3 = None
+    try:
+        cost_mlc_y3 = float(np.sum((mlc_y3 - y2)**2))
+    except FloatingPointError, err:
+        np.seterr(all='ignore')
+        cost_mlc_y3 = float(np.sum((mlc_y3 - y2)**2))
+        np.seterr(all='raise')
+    return cost_mlc_y3
+
+
+def show_best(index, generation, indiv, cost, block=True):
+    x, y, y2, mlc_y3 = individual_data(indiv)
+    # FIXME: Absolute only makes sense if we're working with complex numbers. It's not the case...
+    y4 = np.sqrt((y - mlc_y3)**2 / (1 + np.absolute(x**2)))
+
+    fig = plt.figure()
+    # Put figure window on top of all other windows
+    fig.canvas.manager.window.setWindowModality(Qt.ApplicationModal)
+
+    plt.suptitle("Generation N#{0} - Individual N#{1}\n"
+                 "Cost: {2}\n Formal: {3}".format(generation,
+                                                  index,
+                                                  cost,
+                                                  indiv.get_formal()))
+    plt.subplot(2, 1, 1)
+    plt.plot(x, y, x, y2, '*', x, mlc_y3)
+
+    plt.subplot(2, 1, 2)
+    plt.plot(x, y4, '*r')
+    plt.yscale('log')
+    plt.show(block=block)

tests/mlc/application/numpy_warnings_ev_script.py

@@ -46,7 +46,39 @@ def setUpClass(cls):
     def tearDownClass(cls):
         # Erase the MLC workspace dir of this tests
         shutil.rmtree(ApplicationTest.workspace_dir)
-        pass
+
+    def test_numpy_warnings_on_evaluation_script(self):
+        # MLC catches the numpy warnings and notify them in its log. By doing this,
+        # numpy warnings are set to throw exception. The idea of this test is to
+        # prove that this behaviour (numpy warnings as Exceptions) does not affect
+        # the evaluation scripts
+        experiment_name = "numpy_warnings"
+
+        numpy_ev_script = "numpy_warnings_ev_script.py"
+        numpy_ev_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), numpy_ev_script)
+
+        numpy_config = "numpy_warnings_config.ini"
+        numpy_config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), numpy_config)
+
+        ApplicationTest.mlc_local.new_experiment(experiment_name=experiment_name,
+                                                 experiment_configuration=numpy_config_path,
+                                                 evaluation_script=numpy_ev_path)
+
+        Config.get_instance().set("EVALUATOR", "evaluation_function", "numpy_warnings_ev_script")
+
+        ApplicationTest.mlc_local.open_experiment(experiment_name)
+        try:
+            ApplicationTest.mlc_local.go(experiment_name=experiment_name,
+                                         to_generation=2,
+                                         from_generation=0,
+                                         callbacks={})
+        except FloatingPointError:
+            self.assertEquals(True, False)
+
+        ApplicationTest.mlc_local.close_experiment(experiment_name)
+        ApplicationTest.mlc_local.delete_experiment(experiment_name)
+
+        self.assertEquals(True, True)
 
     def test_callback_on_evaluate(self):
         with saved(Config.get_instance()) as config:

tests/mlc/test_application.py tests/mlc/application/test_application.pytests/mlc/test_application.py renamed to tests/mlc/application/test_application.py

@@ -148,6 +148,17 @@ def test_tree_subtree(self):
         self.assertNode(subtree_1, depth=3, childs=1, expr_index=19)
         self.assertNode(subtree_1._nodes[0], depth=3, childs=0, expr_index=24)
 
+    def test_do_not_raise_exception_when_numpy_warning_appear(self):
+        # This expression raise a numpy warning
+        expression = '(root (cos (exp 1e20)))'
+        tree = LispTreeExpr(expression)
+
+        try:
+            tree.calculate_expression(sensor_replacement_list=[])
+            self.assertEquals(True, True)
+        except FloatingPointError:
+            self.assertEquals(True, False)
+
     def assertNode(self, node, depth, childs, expr_index):
         self.assertEquals(node.get_depth(), depth)
         self.assertEquals(node.get_expr_index(), expr_index)