ADD sklearn flow serialization and deserialization

Author: mfeurer

openml/flows/flow.py

@@ -1,7 +1,11 @@
 from collections import OrderedDict
+import re
+
+import six
 import xmltodict
 
 from .._api_calls import _perform_api_call
+from openml.util import oml_cusual_string
 
 
 class OpenMLFlow(object):
@@ -65,7 +69,7 @@ def __init__(self, name, description=None, model=None, components=None,
         self.parameters_meta_info = parameters_meta_info
 
         self.external_version = external_version
-        self.upoader = uploader
+        self.uploader = uploader
 
         if tags is None:
             tags = []
@@ -100,8 +104,8 @@ def __to_dict(self):
         flow_dict['oml:flow']['@xmlns:oml'] = 'http://openml.org/openml'
         if self.flow_id is not None:
             flow_dict['oml:flow']['oml:id'] = self.flow_id
-        if self.upoader is not None:
-            flow_dict['oml:flow']['oml:uploader'] = self.upoader
+        if self.uploader is not None:
+            flow_dict['oml:flow']['oml:uploader'] = self.uploader
         flow_dict['oml:flow']['oml:name'] = self._get_name()
         if self.version is not None:
             flow_dict['oml:flow']['oml:version'] = self.version
@@ -120,9 +124,20 @@ def __to_dict(self):
             param_dict['oml:name'] = key
             if self.parameters_meta_info[key]['data_type'] is not None:
                 param_dict['oml:data_type'] = self.parameters_meta_info[key].get('data_type')
-            param_dict['oml:default_value'] = self.parameters[key],
+            param_dict['oml:default_value'] = self.parameters[key]
             if self.parameters_meta_info[key]['description'] is not None:
                 param_dict['oml:description'] = self.parameters_meta_info[key].get('description')
+
+            for key, value in param_dict.items():
+                if key is not None and not isinstance(key, six.string_types):
+                    raise ValueError('Parameter name %s cannot be serialized '
+                                     'because it is of type %s. Only strings '
+                                     'can be serialized.' % (key, type(key)))
+                if value is not None and not isinstance(value, six.string_types):
+                    raise ValueError('Parameter value %s cannot be serialized '
+                                     'because it is of type %s. Only strings '
+                                     'can be serialized.' % (value, type(value)))
+
             flow_parameters.append(param_dict)
 
         flow_dict['oml:flow']['oml:parameter'] = flow_parameters
@@ -132,7 +147,17 @@ def __to_dict(self):
             component_dict = OrderedDict()
             component_dict['oml:identifier'] = key
             component_dict['oml:flow'] = self.components[key].__to_dict()['oml:flow']
+
+            for key in component_dict:
+                # We can only check the key here, because the value is a flow.
+                # The flow itself has to be valid by recursion
+                if key is not None and not isinstance(key, six.string_types):
+                    raise ValueError('Parameter name %s cannot be serialized '
+                                     'because it is of type %s. Only strings '
+                                     'can be serialized.' % (key, type(key)))
+
             components.append(component_dict)
+
         flow_dict['oml:flow']['oml:component'] = components
 
         flow_dict['oml:flow']['oml:tag'] = self.tags
@@ -175,7 +200,7 @@ def _from_xml(cls, xml_dict):
                 default_value = oml_parameter['oml:default_value']
                 parameters[parameter_name] = default_value
 
-                meta_info = dict()
+                meta_info = OrderedDict()
                 meta_info['description'] = oml_parameter.get('oml:description')
                 meta_info['data_type'] = oml_parameter.get('oml:data_type')
                 parameters_meta_info[parameter_name] = meta_info
@@ -228,17 +253,30 @@ def __eq__(self, other):
             del other_dict['components']
             del other_dict['model']
 
+            # Name is actually not generated by the server, but it will be tested further down with a getter (allows mocking)
+            generated_by_the_server = ['name', 'flow_id', 'uploader', 'version',
+                                       'upload_date', 'source_url',
+                                       'binary_url', 'source_format',
+                                       'binary_format', 'source_md5',
+                                       'binary_md5']
+            for field in generated_by_the_server:
+                if field in this_dict:
+                    del this_dict[field]
+                if field in other_dict:
+                    del other_dict[field]
+            equal = this_dict == other_dict
+            equal_name = self._get_name() == other._get_name()
+
             parameters_equal = this_parameters.keys() == other_parameters.keys() and \
                                all([this_parameter == other_parameter
                                     for this_parameter, other_parameter in
-                                    zip(this_parameters, other_parameters)])
+                                    zip(this_parameters.values(), other_parameters.values())])
             components_equal = this_components.keys() == other_components.keys() and \
                                all([this_component == other_component
                                     for this_component, other_component in
-                                    zip(this_components, other_components)])
-            equal = this_dict == other_dict
+                                    zip(this_components.values(), other_components.values())])
 
-            return parameters_equal and components_equal and equal
+            return parameters_equal and components_equal and equal and equal_name
         return NotImplemented
 
     def publish(self):
@@ -249,8 +287,15 @@ def publish(self):
         self : OpenMLFlow
 
         """
-        xml_description = self._to_xml()
+        # Checking that the name adheres to oml:casual_string
+        match = re.match(oml_cusual_string, self.name)
+        if not match or ((match.span()[1] - match.span()[0]) < len(self.name)):
+            raise ValueError('Flow name does not adhere to the '
+                             'oml:system_string, the name %s must be matched by '
+                             'the following regular expression: %s' %
+                             (self.name, oml_cusual_string))
 
+        xml_description = self._to_xml()
         file_elements = {'description': xml_description}
         return_code, return_value = _perform_api_call(
             "flow/", file_elements=file_elements)

openml/flows/sklearn.py

@@ -1,6 +1,8 @@
-from collections import OrderedDict
+from collections import OrderedDict, defaultdict
 import importlib
 import inspect
+import json
+import json.decoder
 import six
 import warnings
 
@@ -18,7 +20,9 @@
 
 
 class SklearnToFlowConverter(object):
+
     def serialize_object(self, o):
+
         if self._is_estimator(o) or self._is_transformer(o):
             rval = self.serialize_model(o)
         elif isinstance(o, (list, tuple)):
@@ -29,10 +33,15 @@ def serialize_object(self, o):
             rval = None
         elif isinstance(o, six.string_types):
             rval = o
+        elif isinstance(o, bool):
+            # The check for bool has to be before the check for int, otherwise,
+            # isinstance will think the bool is an int and convert the bool will
+            # be converted to a string which can't be parsed by json.loads
+            rval = json.dumps(o)
         elif isinstance(o, int):
-            rval = o
+            rval = repr(o)
         elif isinstance(o, float):
-            rval = o
+            rval = repr(o)
         elif isinstance(o, dict):
             rval = {}
             for key, value in o.items():
@@ -42,6 +51,7 @@ def serialize_object(self, o):
                 key = self.serialize_object(key)
                 value = self.serialize_object(value)
                 rval[key] = value
+            rval = json.dumps(rval)
         elif isinstance(o, type):
             rval = self.serialize_type(o)
         elif isinstance(o, scipy.stats.distributions.rv_frozen):
@@ -78,38 +88,55 @@ def _is_transformer(self, o):
     def _is_cross_validator(self, o):
         return isinstance(o, sklearn.model_selection.BaseCrossValidator)
 
-    def deserialize_object(self, o):
+    def deserialize_object(self, o, **kwargs):
+        if isinstance(o, six.string_types):
+            try:
+                o = json.loads(o)
+            except json.decoder.JSONDecodeError:
+                pass
+
         if isinstance(o, dict):
             if 'oml:name' in o and 'oml:description' in o:
-                rval = self.deserialize_model(o)
+                rval = self.deserialize_model(o, **kwargs)
             elif 'oml:serialized_object' in o:
                 serialized_type = o['oml:serialized_object']
                 value = o['value']
                 if serialized_type == 'type':
-                    rval = self.deserialize_type(value)
+                    rval = self.deserialize_type(value, **kwargs)
                 elif serialized_type == 'rv_frozen':
-                    rval = self.deserialize_rv_frozen(value)
+                    rval = self.deserialize_rv_frozen(value, **kwargs)
                 elif serialized_type == 'function':
-                    rval = self.deserialize_function(value)
+                    rval = self.deserialize_function(value, **kwargs)
+                elif serialized_type == 'component_reference':
+                    value = self.deserialize_object(value)
+                    step_name = value['step_name']
+                    key = value['key']
+                    component = self.deserialize_object(kwargs['components'][key])
+                    if step_name is None:
+                        rval = component
+                    else:
+                        rval = (step_name, component)
                 else:
                     raise ValueError('Cannot deserialize %s' % serialized_type)
             else:
-                rval = {self.deserialize_object(key): self.deserialize_object(value)
+                rval = {self.deserialize_object(key, **kwargs): self.deserialize_object(value, **kwargs)
                         for key, value in o.items()}
         elif isinstance(o, (list, tuple)):
-            rval = [self.deserialize_object(element) for element in o]
+            rval = [self.deserialize_object(element, **kwargs) for element in o]
             if isinstance(o, tuple):
                 rval = tuple(rval)
-        elif o is None:
-            rval = None
-        elif isinstance(o, six.string_types):
+        elif isinstance(o, bool):
             rval = o
         elif isinstance(o, int):
             rval = o
         elif isinstance(o, float):
             rval = o
+        elif isinstance(o, six.string_types):
+            rval = o
+        elif o is None:
+            rval = None
         elif isinstance(o, OpenMLFlow):
-            rval = self.deserialize_model(o)
+            rval = self.deserialize_model(o, **kwargs)
         else:
             raise TypeError(o)
         assert o is None or rval is not None
@@ -128,9 +155,23 @@ def serialize_model(self, model):
 
             if isinstance(rval, (list, tuple)):
                 # Steps in a pipeline or feature union
+                parameter_value = list()
                 for identifier, sub_component in rval:
-                    sub_components['steps__' + identifier] = sub_component
-                parameters[k] = rval
+                    pos = identifier.find('(')
+                    if pos >= 0:
+                        identifier = identifier[:pos]
+
+                    sub_component_identifier = k + '__' + identifier
+                    sub_components[sub_component_identifier] = sub_component
+                    component_reference = {'oml:serialized_object':'component_reference',
+                                           'value': {'key': sub_component_identifier,
+                                                     'step_name': identifier}}
+                    parameter_value.append(component_reference)
+                if isinstance(rval, tuple):
+                    parameter_value = tuple(parameter_value)
+
+                parameter_value = json.dumps(parameter_value)
+                parameters[k] = parameter_value
 
             elif isinstance(rval, OpenMLFlow):
                 # Since serialize_object can return a Flow, we need to check
@@ -141,9 +182,13 @@ def serialize_model(self, model):
                     continue
 
                 # A subcomponent, for example the base model in AdaBoostClassifier
-                identifier = rval.name
-                sub_components[identifier] = rval
-                parameters[k] = rval
+                sub_components[k] = rval
+                component_reference = {'oml:serialized_object':'component_reference',
+                                           'value': {'key': k,
+                                                     'step_name': None}}
+                component_reference = self.serialize_object(component_reference)
+                parameters[k] = (component_reference)
+
             else:
                 # Since Pipeline and FeatureUnion also return estimators and
                 # transformers in the 'steps' list with get_params(), we must
@@ -183,7 +228,7 @@ def serialize_model(self, model):
 
         return flow
 
-    def deserialize_model(self, flow):
+    def deserialize_model(self, flow, **kwargs):
         # TODO remove potential test sentinel during testing!
         model_name = flow.name
         # Remove everything after the first bracket
@@ -192,11 +237,27 @@ def deserialize_model(self, flow):
             model_name = model_name[:pos]
 
         parameters = flow.parameters
+        components = flow.components
+        component_dict = defaultdict(dict)
         parameter_dict = {}
 
+        for name in components:
+            if '__' in name:
+                parameter_name, step = name.split('__')
+                value = components[name]
+                rval = self.deserialize_object(value)
+                component_dict[parameter_name][step] = rval
+            else:
+                value = components[name]
+                rval = self.deserialize_object(value)
+                parameter_dict[name] = rval
+
         for name in parameters:
             value = parameters.get(name)
-            rval = self.deserialize_object(value)
+            rval = self.deserialize_object(value, components=components)
+            if isinstance(rval, dict) and 'oml:serialized_object' in rval:
+                parameter_name, step = rval['value'].split('__')
+                rval = component_dict[parameter_name][step]
             parameter_dict[name] = rval
 
         module_name = model_name.rsplit('.', 1)
@@ -218,10 +279,11 @@ def serialize_type(self, o):
                    np.int: 'np.int',
                    np.int32: 'np.int32',
                    np.int64: 'np.int64'}
-        return {'oml:serialized_object': 'type',
-                'value': mapping[o]}
+        jason = json.dumps({'oml:serialized_object': 'type',
+                            'value': mapping[o]})
+        return jason
 
-    def deserialize_type(self, o):
+    def deserialize_type(self, o, **kwargs):
         mapping = {'float': float,
                    'np.float': np.float,
                    'np.float32': np.float32,
@@ -238,10 +300,11 @@ def serialize_rv_frozen(self, o):
         a = o.a
         b = o.b
         dist = o.dist.__class__.__module__ + '.' + o.dist.__class__.__name__
-        return {'oml:serialized_object': 'rv_frozen',
-                'value': {'dist': dist, 'a': a, 'b': b, 'args': args, 'kwds': kwds}}
+        jason = json.dumps({'oml:serialized_object': 'rv_frozen',
+                            'value': {'dist': dist, 'a': a, 'b': b, 'args': args, 'kwds': kwds}})
+        return jason
 
-    def deserialize_rv_frozen(self, o):
+    def deserialize_rv_frozen(self, o, **kwargs):
         args = o['args']
         kwds = o['kwds']
         a = o['a']
@@ -264,10 +327,11 @@ def deserialize_rv_frozen(self, o):
 
     def serialize_function(self, o):
         name = o.__module__ + '.' + o.__name__
-        return {'oml:serialized_object': 'function',
-                'value': name}
+        jason = json.dumps({'oml:serialized_object': 'function',
+                            'value': name})
+        return jason
 
-    def deserialize_function(self, name):
+    def deserialize_function(self, name, **kwargs):
         module_name = name.rsplit('.', 1)
         try:
             model_class = getattr(importlib.import_module(module_name[0]),

openml/util.py

@@ -5,11 +5,14 @@
 else:
     from urllib.error import URLError
 
+import six
+
+oml_cusual_string = r'([a-zA-Z0-9_\-,\.\(\)])+'
 
 def is_string(obj):
     try:
         return isinstance(obj, basestring)
     except NameError:
         return isinstance(obj, str)
 
-__all__ = ['URLError', 'is_string']
+__all__ = ['URLError', 'is_string', 'oml_cusual_string']