Remove MatlabEngine from entire project

* Now, the MatlabEngine is used only in the Evaluation and Preevaluation
  scripts
* Decoupled randoms from MatlabEngine singleton. Now the random are managed
  in the singleton class RandomManager
* Tests were modified to pass with the following changes
* Issue #30

Author: Ezetowers

MLC/Application.py

@@ -1,6 +1,4 @@
 from __builtin__ import staticmethod
-
-import matlab.engine
 import MLC.Log.log as lg
 
 from MLC.Common.PreevaluationManager import PreevaluationManager
@@ -18,11 +16,11 @@ class Application(object):
 
     def __init__(self, simulation, log_mode='console'):
         self._config = Config.get_instance()
+        self._simulation = simulation
 
         # Set logger mode of the App
         set_logger(log_mode)
         self._project_validations()
-        self._simulation = simulation
 
         # Gen creator
         gen_method = self._config.get('GP', 'generation_method')
@@ -161,12 +159,11 @@ def show_best(self, population):
         lg.logger_.debug("[APPLICATION] Individual N#{0} - Cost: {1}".format(best_index, best_indiv.get_cost()))
 
         stop_no_graph = self._config.getboolean('BEHAVIOUR', 'stopongraph')
-        EvaluatorFactory.get_ev_callback().show_best(best_index, best_indiv, stop_no_graph)
-
+        EvaluatorFactory.get_callback().show_best(best_index, best_indiv, stop_no_graph)
 
     def _project_validations(self):
         # Check that the evaluation and preevaluation modules can be loaded
-        EvaluatorFactory.get_ev_callback()
+        EvaluatorFactory.get_callback()
         PreevaluationManager.get_callback()
 
     # TODO: Add another validations

MLC/Common/RandomManager.py

@@ -0,0 +1,66 @@
+import os
+import MLC.Log.log as lg
+import random
+
+
+class RandomManager:
+    """
+    Singleton class that manage the way in which the random numbers are generated.
+    The options available at the moment are:
+    * Load MATLAB generated randoms from a fike
+    * Use Python randoms
+    """
+    _rand_counter = 0
+    _randoms = []
+
+    @staticmethod
+    def rand():
+        RandomManager._rand_counter += 1
+        rand_value = None
+        if not len(RandomManager._randoms):
+            rand_value = random.random()
+        else:
+            try:
+                rand_value = RandomManager._randoms.pop(0)
+            except IndexError:
+                lg.logger_.error("[RANDOM_MANAGER] Not enough random values. Aborting program.")
+                raise
+
+        # lg.logger_.debug("[RANDOM_MANAGER] Rand #%d - Value: %.6f" % (RandomManager._rand_counter, rand_value))
+        return rand_value
+
+    @staticmethod
+    def randperm(n):
+        """
+        This function throws as many rands as the value of n and return a
+        list of the indexes of the ordered array of randoms.
+        Example:
+        If n == 5 and the randoms gathered are:
+        0.1 0.9 0.2 0.6 0.3
+        1   2   3   4   5
+        The list returned by the method will be:
+        0.1 0.2 0.3 0.6 0.9
+        1   3   5   4   2
+        [1,3,5,4,2]
+        """
+        RandomManager._rand_counter += n
+        rand_list = []
+
+        for _ in xrange(n):
+            if not len(RandomManager._randoms):
+                rand_list.append(random.random())
+            else:
+                rand_list.append(RandomManager._randoms.pop(0))
+
+        indexes = [x[0] for x in sorted(enumerate(rand_list), key=lambda x:x[1])]
+        return indexes
+
+    @staticmethod
+    def load_random_values(randoms_file):
+        with open(randoms_file) as f:
+            for line in f:
+                RandomManager._randoms.append(float(line))
+
+    @staticmethod
+    def clear_random_values():
+        RandomManager._randoms = []

MLC/Population/Creation/BaseCreation.py

@@ -3,15 +3,13 @@
 
 from MLC.Common.PreevaluationManager import PreevaluationManager
 from MLC.individual.Individual import Individual
-from MLC.matlab_engine import MatlabEngine
 from MLC.mlc_table.MLCTable import MLCTable
 from MLC.mlc_parameters.mlc_parameters import Config
 
 
 class BaseCreation(object):
 
     def __init__(self):
-        self._eng = MatlabEngine.engine()
         self._config = Config.get_instance()
 
         # A list of tuples (index, number)

MLC/Population/Evaluation/EvaluatorFactory.py

@@ -8,7 +8,7 @@
 
 class EvaluatorFactory(object):
     @staticmethod
-    def get_ev_callback():
+    def get_callback():
         module_name = Config.get_instance().get('EVALUATOR', 'evaluation_function')
         lg.logger_.debug('[EV_FACTORY] Importing module {0}'.format(module_name))
         try:
@@ -22,7 +22,7 @@ def get_ev_callback():
     @staticmethod
     def make(strategy):
         if strategy == "mfile_standalone":
-            ev_callback = EvaluatorFactory.get_ev_callback()
+            ev_callback = EvaluatorFactory.get_callback()
             return StandaloneEvaluator(ev_callback)
         else:
             lg.logger_.error("[EV_FACTORY] Evaluation method " +

MLC/Population/Evaluation/StandaloneEvaluator.py

@@ -1,15 +1,13 @@
 import sys
 import MLC.Log.log as lg
 
-from MLC.matlab_engine import MatlabEngine
 from MLC.mlc_parameters.mlc_parameters import Config
 from MLC.mlc_table.MLCTable import MLCTable
 
 
 class StandaloneEvaluator(object):
 
     def __init__(self, callback):
-        self._eng = MatlabEngine.engine()
         self._config = Config.get_instance()
         self._callback = callback
 

MLC/Population/Population.py

@@ -2,12 +2,12 @@
 import MLC.Log.log as lg
 import sys
 
-from MLC.matlab_engine import MatlabEngine
+from MLC.Common.RandomManager import RandomManager
+from MLC.individual.Individual import OperationOverIndividualFail
 from MLC.mlc_table.MLCTable import MLCTable
-from MLC.Population.Evaluation.EvaluatorFactory import EvaluatorFactory
 from MLC.mlc_parameters.mlc_parameters import Config
+from MLC.Population.Evaluation.EvaluatorFactory import EvaluatorFactory
 from MLC.Simulation import Simulation
-from MLC.individual.Individual import OperationOverIndividualFail
 
 
 class Population(object):
@@ -372,7 +372,7 @@ def choose_genetic_operation(amount_indivs_left):
             sys.exit(-1)
 
         op = None
-        rand_prob = MatlabEngine.rand()
+        rand_prob = RandomManager.rand()
         if amount_indivs_left < 2:
             # Crossover is not possible
             rand_prob *= (prob_rep + prob_mut)
@@ -408,7 +408,7 @@ def _choose_individual(self, subgen_range):
                 # subgeneration instead of the indexes
                 random_indiv = -1
                 while random_indiv == -1 or random_indiv in indivs_chosen:
-                    random_indiv = math.ceil(MatlabEngine.rand() * subgen_len) - 1
+                    random_indiv = math.ceil(RandomManager.rand() * subgen_len) - 1
                 indivs_chosen.append(int(random_indiv))
 
             # Got the random indivs. Grab the one with the minor cost

MLC/individual/Individual.py

@@ -3,10 +3,10 @@
 
 import MLC.Log.log as lg
 from collections import Counter
-from MLC.matlab_engine import MatlabEngine
 from MLC.mlc_parameters.mlc_parameters import Config
 from MLC.Common.Operations import Operations
 from MLC.Common.Lisp_Tree_Expr.Lisp_Tree_Expr import Lisp_Tree_Expr
+from MLC.Common.RandomManager import RandomManager
 
 import re
 
@@ -88,7 +88,6 @@ class MutationType:
     _maxdepthfirst = None
 
     def __init__(self, value=None):
-        self._eng = MatlabEngine.engine()
         self._config = Config.get_instance()
         self._tree = None
 
@@ -285,22 +284,22 @@ def __generate_indiv_regressive_tree(self, value, indiv_type=None):
         elif (begin_depth < min_depth and end_str.find('@') == -1) or indiv_type == 3:
             leaf_node = False
         else:
-            leaf_node = MatlabEngine.rand() < self._config.getfloat('POPULATION', 'leaf_prob')
+            leaf_node = RandomManager.rand() < self._config.getfloat('POPULATION', 'leaf_prob')
 
         if leaf_node:
-            use_sensor = MatlabEngine.rand() < self._config.getfloat('POPULATION', 'sensor_prob')
+            use_sensor = RandomManager.rand() < self._config.getfloat('POPULATION', 'sensor_prob')
             if use_sensor:
-                sensor_number = math.ceil(MatlabEngine.rand() * self._config.getint('POPULATION', 'sensors')) - 1
+                sensor_number = math.ceil(RandomManager.rand() * self._config.getint('POPULATION', 'sensors')) - 1
                 new_value = begin_str + 'z' + str(sensor_number).rstrip('0').rstrip('.') + end_str
             else:
                 range = self._config.getfloat('POPULATION', 'range')
                 precision = self._config.get('POPULATION', 'precision')
                 # Generate a float number between -range and +range with a precision of 'precision'
-                new_exp = (("%." + precision + "f") % ((MatlabEngine.rand() - 0.5) * 2 * range))
+                new_exp = (("%." + precision + "f") % ((RandomManager.rand() - 0.5) * 2 * range))
                 new_value = begin_str + new_exp + end_str
         else:
             # Create a node
-            op_num = math.ceil(MatlabEngine.rand() * Operations.get_instance().length())
+            op_num = math.ceil(RandomManager.rand() * Operations.get_instance().length())
             op = Operations.get_instance().get_operation_from_op_num(op_num)
             if (op["nbarg"] == 1):
                 new_value = begin_str + '(' + op["op"] + ' @)' + end_str
@@ -360,7 +359,7 @@ def __mutate_tree(self, expression_tree, mutation_type):
 
         # equi probability for each mutation type selected.
         if mutation_type == Individual.MutationType.ANY:
-            rand_number = MatlabEngine.rand()
+            rand_number = RandomManager.rand()
             mutation_type = mutation_types[int(np.floor(rand_number * len(mutation_types)))]
 
         if mutation_type in [Individual.MutationType.REMOVE_SUBTREE_AND_REPLACE, Individual.MutationType.SHRINK]:
@@ -408,10 +407,10 @@ def __mutate_tree(self, expression_tree, mutation_type):
             changed = False
             k = 0
 
-            for nc in MatlabEngine.randperm(controls):
+            for nc in RandomManager.randperm(controls):
                 k += 1
                 # control law is cropped if it is the last one and no change happend before
-                if (MatlabEngine.rand() < prob_threshold) or (k == controls and not changed):
+                if (RandomManager.rand() < prob_threshold) or (k == controls and not changed):
 
                     try:
                         _, sm, _ = self.__extract_subtree(Lisp_Tree_Expr('(root '+cl[nc - 1]+')'), mutmindepth+1, maxdepth, maxdepth+1)
@@ -439,7 +438,7 @@ def __extract_subtree(self, expression_tree, mindepth, subtreedepthmax, maxdepth
                                 (expression_tree, mindepth, maxdepth, subtreedepthmax))
 
         candidates.sort(key=lambda x: x.get_expr_index(), reverse=False)
-        n = int(np.ceil(MatlabEngine.rand() * len(candidates))) - 1
+        n = int(np.ceil(RandomManager.rand() * len(candidates))) - 1
         extracted_node = candidates[n]
         index = extracted_node.get_expr_index()
         old_value = expression_tree.get_expanded_tree_as_string()
@@ -448,7 +447,7 @@ def __extract_subtree(self, expression_tree, mindepth, subtreedepthmax, maxdepth
 
     def __reparam_tree(self, tree_expression):
         def leaf_value_generator():
-            leaf_value = (MatlabEngine.rand() - 0.5) * 2 * self._range
+            leaf_value = (RandomManager.rand() - 0.5) * 2 * self._range
             return "%0.*f" % (self._precision, leaf_value)
 
         return self.__change_const_tree(tree_expression, leaf_value_generator)

MLC/matlab_engine.py

@@ -4,6 +4,7 @@
 import MLC.Log.log as lg
 import random
 
+
 class MatlabEngine:
     """
     Singleton class that allow to call matlab code from python using the
@@ -16,6 +17,7 @@ class MatlabEngine:
     @staticmethod
     def engine():
         if MatlabEngine._engine_instance is None:
+            lg.logger_.info("[MATLAB_ENGINE] Loading MATLAB environment. Please wait...")
             matlab_code_dir = mlcv3_config.get_matlab_path()
 
             # Check if a MATLAB session exists.
@@ -34,63 +36,5 @@ def engine():
             MatlabEngine._engine_instance.addpath(os.path.join(matlab_code_dir, "MLC_tools"))
             MatlabEngine._engine_instance.addpath(os.path.join(matlab_code_dir, "MLC_tools/Demo"))
 
+        lg.logger_.info("[MATLAB_ENGINE] MATLAB environment loaded succesfully.")
         return MatlabEngine._engine_instance
-
-    @staticmethod
-    def rand():
-        if MatlabEngine._engine_instance is None:
-            raise UnboundLocalError('rand', 'Engine was not initialized')
-
-        MatlabEngine._rand_counter += 1
-        rand_value = None
-        if not len(MatlabEngine._randoms):
-            rand_value = random.random()
-        else:
-            try:
-                rand_value = MatlabEngine._randoms.pop(0)
-            except IndexError:
-                lg.logger_.error("[MATLAB_ENGINE] Not enough random values. Aborting program.")
-                raise
-
-        # lg.logger_.debug("[ENGINE] Rand #%d - Value: %.6f" % (MatlabEngine._rand_counter, rand_value))
-        return rand_value
-
-    @staticmethod
-    def randperm(n):
-        """
-        This function throws as many rands as the value of n and return a
-        list of the indexes of the ordered array of randoms.
-        Example:
-        If n == 5 and the randoms gathered are:
-        0.1 0.9 0.2 0.6 0.3
-        1   2   3   4   5
-        The list returned by the method will be:
-        0.1 0.2 0.3 0.6 0.9
-        1   3   5   4   2
-        [1,3,5,4,2]
-        """
-
-        if MatlabEngine._engine_instance is None:
-            raise UnboundLocalError('rand', 'Engine was not initialized')
-        MatlabEngine._rand_counter += n
-
-        rand_list = []
-        for _ in xrange(n):
-            if not len(MatlabEngine._randoms):
-                rand_list.append(random.random())
-            else:
-                rand_list.append(MatlabEngine._randoms.pop(0))
-
-        indexes = [x[0] for x in sorted(enumerate(rand_list), key=lambda x:x[1])]
-        return indexes
-
-
-    @staticmethod
-    def load_random_values(randoms_file):
-        with open(randoms_file) as f:
-            for line in f:
-                MatlabEngine._randoms.append(float(line))
-
-    @staticmethod
-    def clear_random_values():
-        MatlabEngine._randoms = []

MLC/mlc_parameters/mlc_parameters.py

@@ -1,10 +1,10 @@
 import ConfigParser
 import numpy as np
 import MLC.Log.log as lg
-from MLC.matlab_engine import MatlabEngine
 
 
 class saved():
+
     def __init__(self, cr):
         self.cr = cr
 
@@ -26,9 +26,6 @@ def __init__(self):
         ConfigParser.ConfigParser.__init__(self)
         self._log_prefix = '[CONFIG] '
 
-    def get_matlab_object(self):
-        return MatlabEngine.engine().eval('wmlc.parameters')
-
     def get_list(self, section, param, item_type=int):
         value = self.get(section, param)