Merge pull request #202 from alexbrillant/data-shuffling-epochs-repeater

Add Data Shuffling, And Epochs Repeater Steps

Author: alexbrillant

neuraxle/base.py

@@ -881,7 +881,7 @@ def apply(self, method_name: str, *kargs, **kwargs) -> 'BaseStep':
 
         return self
 
-    def handle_fit(self, data_container: DataContainer, context: ExecutionContext) -> ('BaseStep', DataContainer):
+    def handle_fit(self, data_container: DataContainer, context: ExecutionContext) -> 'BaseStep':
         """
         Override this to add side effects or change the execution flow before (or after) calling :func:`~neuraxle.base.BaseStep.fit`.
         The default behavior is to rehash current ids with the step hyperparameters.
@@ -897,12 +897,9 @@ def handle_fit(self, data_container: DataContainer, context: ExecutionContext) -
         data_container, context = self._will_process(data_container, context)
         data_container, context = self._will_fit(data_container, context)
 
-        new_self, data_container = self._fit_data_container(data_container, context)
+        new_self = self._fit_data_container(data_container, context)
 
-        data_container = self._did_fit(data_container, context)
-        data_container = self._did_process(data_container, context)
-
-        return new_self, data_container
+        return new_self
 
     def handle_fit_transform(self, data_container: DataContainer, context: ExecutionContext) -> ('BaseStep', DataContainer):
         """
@@ -965,7 +962,7 @@ def _did_fit(self, data_container: DataContainer, context: ExecutionContext) ->
         """
         return data_container
 
-    def _fit_data_container(self, data_container: DataContainer, context: ExecutionContext) -> ('BaseStep', DataContainer):
+    def _fit_data_container(self, data_container: DataContainer, context: ExecutionContext) -> 'BaseStep':
         """
         Fit data container.
 
@@ -974,8 +971,7 @@ def _fit_data_container(self, data_container: DataContainer, context: ExecutionC
         :return: (fitted self, data container)
         :rtype: (BaseStep, DataContainer)
         """
-        new_self = self.fit(data_container.data_inputs, data_container.expected_outputs)
-        return new_self, data_container
+        return self.fit(data_container.data_inputs, data_container.expected_outputs)
 
     def _will_fit_transform(self, data_container: DataContainer, context: ExecutionContext) -> (DataContainer, ExecutionContext):
         """
@@ -1634,7 +1630,7 @@ def get_hyperparams(self) -> HyperparameterSamples:
         """
         return HyperparameterSamples({
             **self.hyperparams.to_flat_as_dict_primitive(),
-            self.wrapped.name: self.wrapped.hyperparams.to_flat_as_dict_primitive()
+            self.wrapped.name: self.wrapped.get_hyperparams().to_flat_as_dict_primitive()
         }).to_flat()
 
     def set_hyperparams_space(self, hyperparams_space: HyperparameterSpace) -> 'BaseStep':
@@ -1670,7 +1666,7 @@ def get_hyperparams_space(self) -> HyperparameterSpace:
         """
         return HyperparameterSpace({
             **self.hyperparams_space.to_flat_as_dict_primitive(),
-            self.wrapped.name: self.wrapped.hyperparams_space.to_flat_as_dict_primitive()
+            self.wrapped.name: self.wrapped.get_hyperparams_space().to_flat_as_dict_primitive()
         }).to_flat()
 
     def set_step(self, step: BaseStep) -> BaseStep:
@@ -1703,8 +1699,8 @@ def _fit_transform_data_container(self, data_container, context):
         return self, data_container
 
     def _fit_data_container(self, data_container, context):
-        self.wrapped, data_container = self.wrapped.handle_fit(data_container, context)
-        return self, data_container
+        self.wrapped = self.wrapped.handle_fit(data_container, context)
+        return self
 
     def _transform_data_container(self, data_container, context):
         data_container = self.wrapped.handle_transform(data_container, context)
@@ -1756,6 +1752,39 @@ def apply_method(self, method: Callable, *kargs, **kwargs) -> 'BaseStep':
         self.wrapped = self.wrapped.apply_method(method, *kargs, **kwargs)
         return self
 
+
+    def mutate(self, new_method="inverse_transform", method_to_assign_to="transform", warn=True) -> 'BaseStep':
+        """
+        Mutate self, and self.wrapped. Please refer to :func:`~neuraxle.base.BaseStep.mutate` for more information.
+
+        :param new_method: the method to replace transform with, if there is no pending ``will_mutate_to`` call.
+        :param method_to_assign_to: the method to which the new method will be assigned to, if there is no pending ``will_mutate_to`` call.
+        :param warn: (verbose) wheter or not to warn about the inexistence of the method.
+        :return: self, a copy of self, or even perhaps a new or different BaseStep object.
+        """
+        new_self = BaseStep.mutate(self, new_method, method_to_assign_to, warn)
+        self.wrapped = self.wrapped.mutate(new_method, method_to_assign_to, warn)
+
+        return new_self
+
+    def will_mutate_to(
+            self, new_base_step: 'BaseStep' = None, new_method: str = None, method_to_assign_to: str = None
+    ) -> 'BaseStep':
+        """
+        Add pending mutate self, self.wrapped. Please refer to :func:`~neuraxle.base.BaseStep.will_mutate_to` for more information.
+
+        :param new_base_step: if it is not None, upon calling ``mutate``, the object it will mutate to will be this provided new_base_step.
+        :type new_base_step: BaseStep
+        :param method_to_assign_to: if it is not None, upon calling ``mutate``, the method_to_affect will be the one that is used on the provided new_base_step.
+        :type method_to_assign_to: str
+        :param new_method: if it is not None, upon calling ``mutate``, the new_method will be the one that is used on the provided new_base_step.
+        :type new_method: str
+        :return: self
+        :rtype: BaseStep
+        """
+        new_self = BaseStep.will_mutate_to(self, new_base_step, new_method, method_to_assign_to)
+        return new_self
+
     def __repr__(self):
         output = self.__class__.__name__ + "(\n\twrapped=" + repr(
             self.wrapped) + "," + "\n\thyperparameters=" + pprint.pformat(

neuraxle/checkpoints.py

@@ -207,7 +207,7 @@ def __init__(
         BaseStep.__init__(self)
         self.all_checkpointers = all_checkpointers
 
-    def _fit_data_container(self, data_container, context) -> Tuple['Checkpoint', DataContainer]:
+    def _fit_data_container(self, data_container, context) -> 'Checkpoint':
         """
         Saves step, and data checkpointers for the FIT execution mode.
 
@@ -217,7 +217,7 @@ def _fit_data_container(self, data_container, context) -> Tuple['Checkpoint', Da
         :rtype: neuraxle.data_container.DataContainer
         """
         self.save_checkpoint(data_container, context)
-        return self, data_container
+        return self
 
     def _transform_data_container(self, data_container, context):
         """
@@ -715,7 +715,6 @@ def should_resume(self, data_container: DataContainer, context: ExecutionContext
         if not self.summary_checkpointer.checkpoint_exists(context.get_path(), data_container):
             return False
 
-
         current_ids = self.summary_checkpointer.read_summary(
             checkpoint_path=context.get_path(),
             data_container=data_container

neuraxle/metaopt/random.py

@@ -25,6 +25,7 @@
 """
 
 import copy
+import json
 import math
 from abc import ABC, abstractmethod
 from typing import List, Callable, Tuple, Iterable
@@ -141,7 +142,7 @@ def _fit_transform_data_container(self, data_container: DataContainer, context:
         """
         train_data_container, validation_data_container = self.split_data_container(data_container)
 
-        self.wrapped, _ = self.wrapped.handle_fit(train_data_container, context.push(self.wrapped))
+        self.wrapped = self.wrapped.handle_fit(train_data_container, context.push(self.wrapped))
 
         results_data_container = self.wrapped.handle_transform(train_data_container, context.push(self.wrapped))
 
@@ -581,17 +582,54 @@ def __init__(
             wrapped=None,
             n_iter: int = 10,
             higher_score_is_better: bool = True,
-            validation_technique: BaseCrossValidationWrapper = KFoldCrossValidationWrapper(),
+            validation_technique: BaseValidation = KFoldCrossValidationWrapper(),
             refit=True,
     ):
         if wrapped is not None:
             MetaStepMixin.__init__(self, wrapped)
         BaseStep.__init__(self)
         self.n_iter = n_iter
         self.higher_score_is_better = higher_score_is_better
-        self.validation_technique: BaseCrossValidationWrapper = validation_technique
+        self.validation_technique: BaseValidation = validation_technique
         self.refit = refit
 
+    def _fit_transform_data_container(self, data_container, context):
+        fitted_self = self._fit_data_container(data_container, context)
+        best_model_predictions_data_container = self._transform_data_container(data_container, context)
+        return fitted_self, best_model_predictions_data_container
+
+    def _fit_data_container(self, data_container, context):
+        started = False
+        best_hyperparams = None
+
+        for _ in range(self.n_iter):
+
+            step = copy.copy(self.wrapped)
+
+            new_hyperparams = step.get_hyperparams_space().rvs()
+            step.update_hyperparams(new_hyperparams)
+
+            step: BaseValidation = copy.copy(self.validation_technique).set_step(step)
+
+            step = step.handle_fit(data_container, context)
+            score = step.scores_mean
+
+            if not started or self.higher_score_is_better == (score > self.score):
+                started = True
+                self.score = score
+                self.best_validation_wrapper_of_model = copy.copy(step)
+                print('score: {}'.format(score))
+                best_hyperparams = new_hyperparams
+                print('best_hyperparams: \n{}\n'.format(best_hyperparams))
+
+        self.best_validation_wrapper_of_model.wrapped.update_hyperparams(best_hyperparams)
+
+        self.best_model = copy.copy(self.wrapped).update_hyperparams(best_hyperparams)
+        if self.refit:
+            self.best_model = self.best_model.handle_fit(data_container, context)
+
+        return self
+
     def fit_transform(self, data_inputs, expected_outputs):
         return self.fit(data_inputs, expected_outputs), self.transform(data_inputs)
 
@@ -606,7 +644,7 @@ def fit(self, data_inputs, expected_outputs=None) -> 'BaseStep':
             new_hyperparams = step.get_hyperparams_space().rvs()
             step.set_hyperparams(new_hyperparams)
 
-            step: BaseCrossValidationWrapper = copy.copy(self.validation_technique).set_step(step)
+            step: BaseValidation = copy.copy(self.validation_technique).set_step(step)
 
             step = step.fit(data_inputs, expected_outputs)
             score = step.scores_mean
@@ -615,15 +653,17 @@ def fit(self, data_inputs, expected_outputs=None) -> 'BaseStep':
                 started = True
                 self.score = score
                 self.best_validation_wrapper_of_model = copy.copy(step)
+
+                print('\nbest_score: {}'.format(score))
                 best_hyperparams = new_hyperparams
+                print('best_hyperparams: ')
+                print(json.dumps(best_hyperparams.to_nested_dict(), sort_keys=True, indent=4))
 
         self.best_validation_wrapper_of_model.wrapped.set_hyperparams(best_hyperparams)
 
+        self.best_model = copy.copy(self.wrapped).set_hyperparams(best_hyperparams)
         if self.refit:
-            self.best_model = self.best_validation_wrapper_of_model.wrapped.fit(
-                data_inputs,
-                expected_outputs
-            )
+            self.best_model = self.best_model.fit(data_inputs, expected_outputs)
 
         return self
 
@@ -634,3 +674,9 @@ def transform(self, data_inputs):
         if self.best_validation_wrapper_of_model is None:
             raise Exception('Cannot transform RandomSearch before fit')
         return self.best_validation_wrapper_of_model.wrapped.transform(data_inputs)
+
+    def _transform_data_container(self, data_container, context):
+        if self.best_validation_wrapper_of_model is None:
+            raise Exception('Cannot transform RandomSearch before fit')
+
+        return self.best_validation_wrapper_of_model.wrapped.handle_transform(data_container, context)

neuraxle/pipeline.py

@@ -116,7 +116,7 @@ def fit(self, data_inputs, expected_outputs=None) -> 'Pipeline':
         data_container = self.hash_data_container(data_container)
         context = ExecutionContext(self.cache_folder, ExecutionMode.FIT)
         context = context.push(self)
-        new_self, data_container = self._fit_data_container(data_container, context)
+        new_self = self._fit_data_container(data_container, context)
 
         return new_self
 
@@ -131,7 +131,7 @@ def inverse_transform(self, processed_outputs) -> Any:
             processed_outputs = step.inverse_transform(processed_outputs)
         return processed_outputs
 
-    def _fit_data_container(self, data_container: DataContainer, context: ExecutionContext) -> ('Pipeline', DataContainer):
+    def _fit_data_container(self, data_container: DataContainer, context: ExecutionContext) -> 'Pipeline':
         """
         After loading the last checkpoint, fit transform each pipeline steps,
         but only fit the last pipeline step.
@@ -153,14 +153,14 @@ def _fit_data_container(self, data_container: DataContainer, context: ExecutionC
             if index != index_last_step:
                 step, data_container = step.handle_fit_transform(data_container, context)
             else:
-                step, data_container = step.handle_fit(data_container, context)
+                step = step.handle_fit(data_container, context)
 
             new_steps_as_tuple.append((step_name, step))
 
         self.steps_as_tuple = self.steps_as_tuple[
                               :len(self.steps_as_tuple) - len(steps_left_to_do)] + new_steps_as_tuple
 
-        return self, data_container
+        return self
 
     def _fit_transform_data_container(self, data_container: DataContainer, context: ExecutionContext) -> (
             'Pipeline', DataContainer):
@@ -334,7 +334,7 @@ def fit(self, data_inputs, expected_outputs=None) -> 'Pipeline':
         data_container.set_current_ids(current_ids)
 
         context = ExecutionContext(self.cache_folder, ExecutionMode.FIT_TRANSFORM)
-        new_self, data_container = self.handle_fit(data_container, context)
+        new_self = self.handle_fit(data_container, context)
 
         return new_self
 

neuraxle/steps/caching.py

@@ -22,17 +22,18 @@
     project, visit https://www.umaneo.com/ for more information on Umaneo Technologies Inc.
 
 """
+import hashlib
 import os
 import pickle
 import shutil
-from abc import abstractmethod
+from abc import abstractmethod, ABC
 from typing import Iterable, Any
 
 from neuraxle.base import MetaStepMixin, BaseStep, NonFittableMixin, NonTransformableMixin, \
     ExecutionContext
 from neuraxle.data_container import DataContainer
 from neuraxle.pipeline import DEFAULT_CACHE_FOLDER
-from neuraxle.steps.misc import BaseValueHasher, Md5Hasher, VALUE_CACHING
+from neuraxle.steps.misc import VALUE_CACHING
 
 
 class ValueCachingWrapper(MetaStepMixin, NonFittableMixin, NonTransformableMixin, BaseStep):
@@ -44,7 +45,7 @@ def __init__(
             self,
             wrapped: BaseStep,
             cache_folder: str = DEFAULT_CACHE_FOLDER,
-            value_hasher: BaseValueHasher = None,
+            value_hasher: 'BaseValueHasher' = None,
     ):
         BaseStep.__init__(self)
         MetaStepMixin.__init__(self, wrapped)
@@ -214,3 +215,17 @@ def contains_cache_for(self, data_input) -> bool:
     def get_cache_path_for(self, data_input):
         hash_value = self._hash_value(data_input)
         return os.path.join(self.checkpoint_path, '{0}.pickle'.format(hash_value))
+
+
+class BaseValueHasher(ABC):
+    @abstractmethod
+    def hash(self, data_input):
+        raise NotImplementedError()
+
+
+class Md5Hasher(BaseValueHasher):
+    def hash(self, data_input):
+        m = hashlib.md5()
+        m.update(str.encode(str(data_input)))
+
+        return m.hexdigest()