Merge pull request #102 from HDI-Project/issue-96-allow-passing-fit-and-produce-args-as-init_params

Allow passing fit and produce args as init params

Author: csala

mlblocks/mlblock.py

@@ -13,8 +13,11 @@
 
 def import_object(object_name):
     """Import an object from its Fully Qualified Name."""
-    package, name = object_name.rsplit('.', 1)
-    return getattr(importlib.import_module(package), name)
+    if isinstance(object_name, str):
+        package, name = object_name.rsplit('.', 1)
+        return getattr(importlib.import_module(package), name)
+
+    return object_name
 
 
 class MLBlock():
@@ -27,7 +30,7 @@ class MLBlock():
 
     Attributes:
         name (str):
-            Name given to this MLBlock.
+            Primitive name.
         metadata (dict):
             Additional information about this primitive
         primitive (object):
@@ -46,8 +49,8 @@ class MLBlock():
             function.
 
     Args:
-        name (str):
-            Name given to this MLBlock.
+        primitive (str or dict):
+            primitive name or primitive dictionary.
         **kwargs:
             Any additional arguments that will be used as hyperparameters or passed to the
             ``fit`` or ``produce`` methods.
@@ -143,10 +146,12 @@ def _get_tunable(cls, hyperparameters, init_params):
 
         return tunable
 
-    def __init__(self, name, **kwargs):
-        self.name = name
+    def __init__(self, primitive, **kwargs):
+        if isinstance(primitive, str):
+            primitive = load_primitive(primitive)
 
-        self.metadata = load_primitive(name)
+        self.metadata = primitive
+        self.name = primitive['name']
 
         self.primitive = import_object(self.metadata['primitive'])
 
@@ -252,11 +257,9 @@ def _get_method_kwargs(self, kwargs, method_args):
 
             if name in kwargs:
                 value = kwargs[name]
-
             elif 'default' in arg:
                 value = arg['default']
-
-            else:
+            elif arg.get('required', True):
                 raise TypeError("missing expected argument '{}'".format(name))
 
             method_kwargs[keyword] = value

mlblocks/mlpipeline.py

@@ -87,16 +87,21 @@ def _build_blocks(self):
 
         block_names_count = Counter()
         for primitive in self.primitives:
+            if isinstance(primitive, str):
+                primitive_name = primitive
+            else:
+                primitive_name = primitive['name']
+
             try:
-                block_names_count.update([primitive])
-                block_count = block_names_count[primitive]
-                block_name = '{}#{}'.format(primitive, block_count)
+                block_names_count.update([primitive_name])
+                block_count = block_names_count[primitive_name]
+                block_name = '{}#{}'.format(primitive_name, block_count)
                 block_params = self.init_params.get(block_name, dict())
                 if not block_params:
-                    block_params = self.init_params.get(primitive, dict())
+                    block_params = self.init_params.get(primitive_name, dict())
                     if block_params and block_count > 1:
                         LOGGER.warning(("Non-numbered init_params are being used "
-                                        "for more than one block %s."), primitive)
+                                        "for more than one block %s."), primitive_name)
 
                 block = MLBlock(primitive, **block_params)
                 blocks[block_name] = block
@@ -330,10 +335,6 @@ def _get_block_args(self, block_name, block_args, context):
 
             if variable in context:
                 kwargs[name] = context[variable]
-            elif 'default' in arg:
-                kwargs[name] = arg['default']
-            elif arg.get('required', True):
-                raise ValueError('Input variable {} not found in context'.format(variable))
 
         return kwargs
 
@@ -517,11 +518,12 @@ def fit(self, X=None, y=None, output_=None, start_=None, **kwargs):
                   the value of that variable from the context will extracted and returned
                   after the produce method of that block has been called.
         """
-        context = {
-            'X': X,
-            'y': y
-        }
-        context.update(kwargs)
+        context = kwargs.copy()
+        if X is not None:
+            context['X'] = X
+
+        if y is not None:
+            context['y'] = y
 
         output_block, output_variable = self._get_output_spec(output_)
         last_block_name = self._get_block_name(-1)
@@ -624,10 +626,9 @@ def predict(self, X=None, output_=None, start_=None, **kwargs):
                   the value of that variable from the context will extracted and returned
                   after the produce method of that block has been called.
         """
-        context = {
-            'X': X
-        }
-        context.update(kwargs)
+        context = kwargs.copy()
+        if X is not None:
+            context['X'] = X
 
         output_block, output_variable = self._get_output_spec(output_)
 

tests/features/test_fit_predicr_args.py

@@ -0,0 +1,42 @@
+from mlblocks.mlpipeline import MLPipeline
+
+
+def test_fit_predict_args_in_init():
+
+    def add(a, b):
+        return a + b
+
+    primitive = {
+        'name': 'add',
+        'primitive': add,
+        'produce': {
+            'args': [
+                {
+                    'name': 'a',
+                    'type': 'float',
+                },
+                {
+                    'name': 'b',
+                    'type': 'float',
+                },
+            ],
+            'output': [
+                {
+                    'type': 'float',
+                    'name': 'out'
+                }
+            ]
+        }
+    }
+
+    primitives = [primitive]
+    init_params = {
+        'add': {
+            'b': 10
+        }
+    }
+    pipeline = MLPipeline(primitives, init_params=init_params)
+
+    out = pipeline.predict(a=3)
+
+    assert out == 13

tests/test_mlblock.py

@@ -323,6 +323,7 @@ def test__get_tunable_condition_match_null(self):
     @patch('mlblocks.mlblock.load_primitive')
     def test___init__(self, load_primitive_mock, import_object_mock, set_hps_mock):
         load_primitive_mock.return_value = {
+            'name': 'a_primitive_name',
             'primitive': 'a_primitive_name',
             'produce': {
                 'args': [
@@ -335,9 +336,22 @@ def test___init__(self, load_primitive_mock, import_object_mock, set_hps_mock):
             }
         }
 
-        mlblock = MLBlock('given_primitive_name', argument='value')
+        mlblock = MLBlock('a_primitive_name', argument='value')
 
-        assert mlblock.name == 'given_primitive_name'
+        assert mlblock.metadata == {
+            'name': 'a_primitive_name',
+            'primitive': 'a_primitive_name',
+            'produce': {
+                'args': [
+                    {
+                        'name': 'argument'
+                    }
+                ],
+                'output': [
+                ]
+            }
+        }
+        assert mlblock.name == 'a_primitive_name'
         assert mlblock.primitive == import_object_mock.return_value
         assert mlblock._fit == dict()
         assert mlblock.fit_args == list()
@@ -370,22 +384,24 @@ def test___init__(self, load_primitive_mock, import_object_mock, set_hps_mock):
     @patch('mlblocks.mlblock.load_primitive')
     def test___str__(self, load_primitive_mock, import_object_mock):
         load_primitive_mock.return_value = {
+            'name': 'a_primitive_name',
             'primitive': 'a_primitive_name',
             'produce': {
                 'args': [],
                 'output': []
             }
         }
 
-        mlblock = MLBlock('given_primitive_name')
+        mlblock = MLBlock('a_primitive_name')
 
-        assert str(mlblock) == 'MLBlock - given_primitive_name'
+        assert str(mlblock) == 'MLBlock - a_primitive_name'
 
     @patch('mlblocks.mlblock.import_object')
     @patch('mlblocks.mlblock.load_primitive')
     def test_get_tunable_hyperparameters(self, load_primitive_mock, import_object_mock):
         """get_tunable_hyperparameters has to return a copy of the _tunables attribute."""
         load_primitive_mock.return_value = {
+            'name': 'a_primitive_name',
             'primitive': 'a_primitive_name',
             'produce': {
                 'args': [],
@@ -433,6 +449,7 @@ def primitive(a_list_param):
         io_mock.return_value = primitive
 
         lp_mock.return_value = {
+            'name': 'a_primitive',
             'primitive': 'a_primitive',
             'produce': {
                 'args': [],

tests/test_mlpipeline.py

@@ -270,7 +270,6 @@ def test__get_block_args(self):
 
         expected = {
             'arg_1': 'arg_1_value',
-            'arg_2': 'arg_2_value',
             'arg_3': 'arg_3_value',
         }
         assert args == expected