only check parameters of component if it is not older than the parent flow

Author: mfeurer

openml/flows/flow.py

@@ -349,15 +349,15 @@ def publish(self):
         return_value = _perform_api_call("flow/", file_elements=file_elements)
         flow_id = int(xmltodict.parse(return_value)['oml:upload_flow']['oml:id'])
         flow = openml.flows.functions.get_flow(flow_id)
+        _copy_server_fields(flow, self)
         try:
-            openml.flows.functions.assert_flows_equal(self, flow)
+            openml.flows.functions.assert_flows_equal(self, flow, flow.upload_date)
         except ValueError as e:
             message = e.args[0]
             raise ValueError("Flow was not stored correctly on the server. "
                              "New flow ID is %d. Please check manually and "
                              "remove the flow if necessary! Error is:\n'%s'" %
                              (flow_id, message))
-        _copy_server_fields(flow, self)
         return self
 
 

openml/flows/functions.py

@@ -1,3 +1,5 @@
+import dateutil.parser
+
 import xmltodict
 import six
 
@@ -143,11 +145,21 @@ def _check_flow_for_server_id(flow):
                 stack.append(component)
 
 
-def assert_flows_equal(flow1, flow2):
+def assert_flows_equal(flow1, flow2, ignore_parameters_on_older_children=None):
     """Check equality of two flows.
 
     Two flows are equal if their all keys which are not set by the server
     are equal, as well as all their parameters and components.
+
+    Parameters
+    ----------
+    flow1 : OpenMLFlow
+
+    flow2 : OpenMLFlow
+
+    ignore_parameters_on_older_children : str
+        If set to ``OpenMLFlow.upload_date``, ignores parameters in a child
+        flow if it's upload date predates the upload date of the parent flow.
     """
     if not isinstance(flow1, OpenMLFlow):
         raise TypeError('Argument 1 must be of type OpenMLFlow, but is %s' %
@@ -157,6 +169,8 @@ def assert_flows_equal(flow1, flow2):
         raise TypeError('Argument 2 must be of type OpenMLFlow, but is %s' %
                         type(flow2))
 
+    # TODO as they are actually now saved during publish, it might be good to
+    # check for the equality of these as well.
     generated_by_the_server = ['flow_id', 'uploader', 'version', 'upload_date']
     ignored_by_python_API = ['binary_url', 'binary_format', 'binary_md5',
                              'model']
@@ -174,9 +188,18 @@ def assert_flows_equal(flow1, flow2):
                 if not name in attr2:
                     raise ValueError('Component %s only available in '
                                      'argument2, but not in argument1.' % name)
-                assert_flows_equal(attr1[name], attr2[name])
+                assert_flows_equal(attr1[name], attr2[name], ignore_parameters_on_older_children)
 
         else:
+            if key == 'parameters':
+                if ignore_parameters_on_older_children:
+                    upload_date_current_flow = dateutil.parser.parse(
+                        flow1.upload_date)
+                    upload_date_parent_flow = dateutil.parser.parse(
+                        ignore_parameters_on_older_children)
+                    if upload_date_current_flow < upload_date_parent_flow:
+                        continue
+
             if attr1 != attr2:
                 raise ValueError("Flow %s: values for attribute '%s' differ: "
                                  "'%s' vs '%s'." %

tests/test_flows/test_flow.py

@@ -28,6 +28,7 @@
 from openml._api_calls import _perform_api_call
 import openml
 from openml.flows.sklearn_converter import _format_external_version
+import openml.exceptions
 
 
 class TestFlow(TestBase):
@@ -120,6 +121,50 @@ def test_publish_flow(self):
         flow.publish()
         self.assertIsInstance(flow.flow_id, int)
 
+    def test_publish_existing_flow(self):
+        clf = sklearn.tree.DecisionTreeClassifier(max_depth=2)
+        flow = openml.flows.sklearn_to_flow(clf)
+        flow, _ = self._add_sentinel_to_flow_name(flow, None)
+        flow.publish()
+        self.assertRaisesRegexp(openml.exceptions.OpenMLServerException,
+                                'flow already exists', flow.publish)
+
+    def test_publish_flow_with_similar_components(self):
+        clf = sklearn.ensemble.VotingClassifier(
+            [('lr', sklearn.linear_model.LogisticRegression())])
+        flow = openml.flows.sklearn_to_flow(clf)
+        flow, _ = self._add_sentinel_to_flow_name(flow, None)
+        flow.publish()
+        # For a flow where both components are published together, the upload
+        # date should be equal
+        self.assertEqual(flow.upload_date,
+                         flow.components['lr'].upload_date,
+                         (flow.name, flow.flow_id,
+                          flow.components['lr'].name, flow.components['lr'].flow_id))
+
+        clf1 = sklearn.tree.DecisionTreeClassifier(max_depth=2)
+        flow1 = openml.flows.sklearn_to_flow(clf1)
+        flow1, sentinel = self._add_sentinel_to_flow_name(flow1, None)
+        flow1.publish()
+
+        clf2 = sklearn.ensemble.VotingClassifier(
+            [('dt', sklearn.tree.DecisionTreeClassifier(max_depth=2))])
+        flow2 = openml.flows.sklearn_to_flow(clf2)
+        flow2, _ = self._add_sentinel_to_flow_name(flow2, sentinel)
+        flow2.publish()
+        # If one component was published before the other, the components in
+        # the flow should have different upload dates
+        self.assertNotEqual(flow2.upload_date,
+                            flow2.components['dt'].upload_date)
+
+        clf3 = sklearn.ensemble.AdaBoostClassifier(
+            sklearn.tree.DecisionTreeClassifier(max_depth=3))
+        flow3 = openml.flows.sklearn_to_flow(clf3)
+        flow3, _ = self._add_sentinel_to_flow_name(flow3, sentinel)
+        # Child flow has different parameter. Check for storing the flow
+        # correctly on the server should thus not check the child's parameters!
+        flow3.publish()
+
     def test_semi_legal_flow(self):
         # TODO: Test if parameters are set correctly!
         # should not throw error as it contains two differentiable forms of Bagging