FIX serialize each parameter as json

Author: mfeurer

openml/flows/sklearn.py

@@ -37,11 +37,11 @@ def serialize_object(self, o):
             # 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)
+            rval = o
         elif isinstance(o, int):
-            rval = repr(o)
+            rval = o
         elif isinstance(o, float):
-            rval = repr(o)
+            rval = o
         elif isinstance(o, dict):
             rval = {}
             for key, value in o.items():
@@ -51,7 +51,7 @@ def serialize_object(self, o):
                 key = self.serialize_object(key)
                 value = self.serialize_object(value)
                 rval[key] = value
-            rval = json.dumps(rval)
+            rval = rval
         elif isinstance(o, type):
             rval = self.serialize_type(o)
         elif isinstance(o, scipy.stats.distributions.rv_frozen):
@@ -187,7 +187,7 @@ def serialize_model(self, model):
                                            'value': {'key': k,
                                                      'step_name': None}}
                 component_reference = self.serialize_object(component_reference)
-                parameters[k] = (component_reference)
+                parameters[k] = json.dumps(component_reference)
 
             else:
                 # Since Pipeline and FeatureUnion also return estimators and
@@ -201,6 +201,7 @@ def serialize_model(self, model):
 
                 # a regular hyperparameter
                 if not (hasattr(rval, '__len__') and len(rval) == 0):
+                    rval = json.dumps(rval)
                     parameters[k] = rval
                 else:
                     parameters[k] = None
@@ -279,9 +280,8 @@ def serialize_type(self, o):
                    np.int: 'np.int',
                    np.int32: 'np.int32',
                    np.int64: 'np.int64'}
-        jason = json.dumps({'oml:serialized_object': 'type',
-                            'value': mapping[o]})
-        return jason
+        return {'oml:serialized_object': 'type',
+                            'value': mapping[o]}
 
     def deserialize_type(self, o, **kwargs):
         mapping = {'float': float,
@@ -300,9 +300,8 @@ def serialize_rv_frozen(self, o):
         a = o.a
         b = o.b
         dist = o.dist.__class__.__module__ + '.' + o.dist.__class__.__name__
-        jason = json.dumps({'oml:serialized_object': 'rv_frozen',
-                            'value': {'dist': dist, 'a': a, 'b': b, 'args': args, 'kwds': kwds}})
-        return jason
+        return {'oml:serialized_object': 'rv_frozen',
+                            'value': {'dist': dist, 'a': a, 'b': b, 'args': args, 'kwds': kwds}}
 
     def deserialize_rv_frozen(self, o, **kwargs):
         args = o['args']
@@ -327,9 +326,8 @@ def deserialize_rv_frozen(self, o, **kwargs):
 
     def serialize_function(self, o):
         name = o.__module__ + '.' + o.__name__
-        jason = json.dumps({'oml:serialized_object': 'function',
-                            'value': name})
-        return jason
+        return {'oml:serialized_object': 'function',
+                            'value': name}
 
     def deserialize_function(self, name, **kwargs):
         module_name = name.rsplit('.', 1)

openml/testing.py

@@ -44,7 +44,7 @@ def setUp(self):
         openml.config.apikey = "610344db6388d9ba34f6db45a3cf71de"
 
         self.production_server = openml.config.server
-        self.test_server = "http://test.openml.org/api/v1/xml"
+        self.test_server = "http://capa.win.tue.nl/api/v1/xml"
         openml.config.server = self.test_server
         openml.config.set_cache_directory(self.workdir, self.workdir)
 

tests/flows/test_flow.py

@@ -114,6 +114,7 @@ def test_publish_flow(self, name_mock):
 
         flow = openml.OpenMLFlow(name='Test',
                                  description="test description",
+                                 external_version=str(sklearn.__version__),
                                  model=sklearn.dummy.DummyClassifier())
         name_mock.return_value = 'TEST%s%s' % (sentinel, flow.name)
 
@@ -128,6 +129,12 @@ def test_sklearn_to_upload_to_flow(self, name_mock):
         md5 = hashlib.md5()
         md5.update(str(time.time()).encode('utf-8'))
         sentinel = md5.hexdigest()[:10]
+        def side_effect(self):
+            if sentinel in self.name:
+                return self.name
+            else:
+                return 'TEST%s%s' % (sentinel, self.name)
+        name_mock.side_effect = side_effect
 
         # Test a more complicated flow
         scaler = sklearn.preprocessing.StandardScaler(with_mean=False)
@@ -141,7 +148,6 @@ def test_sklearn_to_upload_to_flow(self, name_mock):
         rs = sklearn.model_selection.RandomizedSearchCV(
             estimator=model, param_distributions=parameter_grid)
         flow = openml.flows.create_flow_from_model(rs, SklearnToFlowConverter())
-        name_mock.return_value = 'TEST%s%s' % (sentinel, flow.name)
 
         flow.publish()
         self.assertIsInstance(flow.flow_id, int)

tests/flows/test_sklearn.py

@@ -3,6 +3,7 @@
 import unittest
 
 import numpy as np
+import sklearn.base
 import sklearn.datasets
 import scipy.stats
 import sklearn.decomposition
@@ -18,6 +19,13 @@
 from openml.flows import OpenMLFlow
 
 
+class Model(sklearn.base.BaseEstimator):
+    def __init__(self, boolean, integer, floating_point_value):
+        self.boolean = boolean
+        self.integer = integer
+        self.floating_point_value = floating_point_value
+
+
 class TestSklearn(unittest.TestCase):
 
     def setUp(self):
@@ -34,18 +42,18 @@ def test_serialize_model(self):
         fixture_name = 'sklearn.tree.tree.DecisionTreeClassifier'
         fixture_description = 'Automatically created sub-component.'
         fixture_parameters = \
-            OrderedDict((('class_weight', None),
-                         ('criterion', 'entropy'),
-                         ('max_depth', None),
-                         ('max_features', 'auto'),
+            OrderedDict((('class_weight', 'null'),
+                         ('criterion', '"entropy"'),
+                         ('max_depth', 'null'),
+                         ('max_features', '"auto"'),
                          ('max_leaf_nodes', '2000'),
                          ('min_impurity_split', '1e-07'),
                          ('min_samples_leaf', '1'),
                          ('min_samples_split', '2'),
                          ('min_weight_fraction_leaf', '0.0'),
                          ('presort', 'false'),
-                         ('random_state', None),
-                         ('splitter', 'best')))
+                         ('random_state', 'null'),
+                         ('splitter', '"best"')))
 
         serialization = self.converter.serialize_object(model)
 
@@ -73,7 +81,7 @@ def test_serialize_model_with_subcomponent(self):
 
         self.assertEqual(serialization.name, fixture_name)
         self.assertEqual(serialization.description, fixture_description)
-        self.assertEqual(serialization.parameters['algorithm'], 'SAMME.R')
+        self.assertEqual(serialization.parameters['algorithm'], '"SAMME.R"')
         self.assertIsInstance(serialization.parameters['base_estimator'], str)
         self.assertEqual(serialization.parameters['learning_rate'], '1.0')
         self.assertEqual(serialization.parameters['n_estimators'], '100')
@@ -294,11 +302,14 @@ def test_serialize_resampling(self):
         self.assertIsNot(deserialized, kfold)
 
     def test_hypothetical_parameter_values(self):
-        values = ['true', '1', '0.1']
-        for value in values:
-            serialized = self.converter.serialize_object(value)
-            deserialized = self.converter.deserialize_object(value)
-            self.assertEqual(deserialized, value)
+        # Can only be checked inside a model
+
+        model = Model('true', '1', '0.1')
+
+        serialized = self.converter.serialize_object(model)
+        deserialized = self.converter.deserialize_object(serialized)
+        self.assertEqual(deserialized.get_params(), model.get_params())
+        self.assertIsNot(deserialized, model)
 
 
 

tests/tasks/test_task_functions.py

@@ -52,15 +52,15 @@ def _check_task(self, task):
     def test_list_tasks_by_type(self):
         ttid=3
         tasks = openml.tasks.list_tasks(task_type_id=ttid)
-        self.assertGreaterEqual(len(tasks), 300)
+        self.assertGreaterEqual(len(tasks), 286)
         for tid in tasks:
             print(tasks[tid])
             self.assertEquals(ttid, tasks[tid]["ttid"])
             self._check_task(tasks[tid])
 
     def test_list_tasks_by_tag(self):
         tasks = openml.tasks.list_tasks(tag='basic')
-        self.assertGreaterEqual(len(tasks), 57)
+        self.assertGreaterEqual(len(tasks), 54)
         for tid in tasks:
             self._check_task(tasks[tid])