diff --git a/gquant/dataframe_flow/node.py b/gquant/dataframe_flow/node.py
index 9b6f2e34..61a96896 100644
--- a/gquant/dataframe_flow/node.py
+++ b/gquant/dataframe_flow/node.py
@@ -7,7 +7,29 @@
 import dask
 
 
-__all__ = ['Node']
+__all__ = ['Node', 'TaskSpecSchema']
+
+
+class TaskSpecSchema(object):
+    '''Outline fields expected in a dictionary specifying a task node.
+
+    :ivar id: unique id or name for the node
+    :ivar plugin_type: Plugin class i.e. subclass of Node. Specified as string
+        or subclass of Node
+    :ivar conf: Configuration for the plugin i.e. parameterization. This is a
+        dictionary.
+    :ivar modulepath: Path to python module for custom plugin types.
+    :ivar inputs: List of ids of other tasks or an empty list.
+    '''
+
+    uid = 'id'
+    plugin_type = 'type'
+    conf = 'conf'
+    modulepath = 'filepath'
+    inputs = 'inputs'
+
+    # load = 'load'
+    # save = 'save'
 
 
 class Node(object):
diff --git a/gquant/dataframe_flow/workflow.py b/gquant/dataframe_flow/workflow.py
index 54af6e40..7d6d2846 100644
--- a/gquant/dataframe_flow/workflow.py
+++ b/gquant/dataframe_flow/workflow.py
@@ -6,7 +6,7 @@
 
 from .node import Node
 
-__all__ = ['run', 'save_workflow', 'load_workflow', 'viz_graph', 'get_graph']
+__all__ = ['run', 'save_workflow', 'load_workflow', 'viz_graph', 'build_workflow']
 
 
 DEFAULT_MODULE = "gquant.plugin_nodes"
@@ -109,72 +109,82 @@ def __find_roots(node, inputs, consider_load=True):
         __find_roots(i, inputs, consider_load)
 
 
-def get_graph(obj, replace):
+def build_workflow(task_list, replace=None):
     """
     compute the graph structure of the nodes. It will set the input and output
     nodes for each of the node
 
     Arguments
     -------
-    obj: list
-        a list of Python object that defines the nodes
+    task_list: list
+        A list of Python dicts. Each dict is a task node spec.
     replace: dict
         conf parameters replacement
+
     Returns
     -----
     dict
         keys are Node unique ids
-        values are Node objects
+        values are instances of Node subclasses i.e. plugins.
 
     """
-
-    obj_dict = {}
-    conf_dict = {}
+    replace = dict() if replace is None else replace
+    task_dict = {}
+    task_spec_dict = {}
     # instantiate objects
-    for o in obj:
-        if o['id'] in replace:
-            o = copy.deepcopy(o)
-            o.update(replace[o['id']])
-        if isinstance(o['type'], str):
-            if 'filepath' in o:
-                spec = importlib.util.spec_from_file_location(o['id'],
-                                                              o['filepath'])
+    for task_spec in task_list:
+        if task_spec['id'] in replace:
+            task_spec = copy.deepcopy(task_spec)
+            task_spec.update(replace[task_spec['id']])
+
+        if isinstance(task_spec['type'], str):
+            if 'filepath' in task_spec:
+                spec = importlib.util.spec_from_file_location(task_spec['id'],
+                                                              task_spec['filepath'])
                 mod = importlib.util.module_from_spec(spec)
                 spec.loader.exec_module(mod)
-                NodeClass = getattr(mod, o['type'])
+                NodeClass = getattr(mod, task_spec['type'])
             else:
-                NodeClass = getattr(mod_lib, o['type'])
-        elif issubclass(o['type'], Node):
-            NodeClass = o['type']
+                NodeClass = getattr(mod_lib, task_spec['type'])
+        elif issubclass(task_spec['type'], Node):
+            NodeClass = task_spec['type']
         else:
             raise "Not supported"
+
         load = False
         save = False
-        if 'load' in o:
-            load = o['load']
-        if 'save' in o:
-            save = o['save']
-        instance = NodeClass(o['id'], o['conf'], load, save)
-        obj_dict[o['id']] = instance
-        conf_dict[o['id']] = o
+
+        if 'load' in task_spec:
+            load = task_spec['load']
+
+        if 'save' in task_spec:
+            save = task_spec['save']
+
+        instance = NodeClass(task_spec['id'], task_spec['conf'], load, save)
+        task_dict[task_spec['id']] = instance
+        task_spec_dict[task_spec['id']] = task_spec
+
     # build the graph
-    for key in obj_dict:
-        instance = obj_dict[key]
-        for input_id in conf_dict[key]['inputs']:
-            input_instance = obj_dict[input_id]
+    for task_id in task_dict:
+        instance = task_dict[task_id]
+        for input_id in task_spec_dict[task_id]['inputs']:
+            input_instance = task_dict[input_id]
             instance.inputs.append(input_instance)
             input_instance.outputs.append(instance)
 
     # this part is to do static type checks
     raw_inputs = []
-    for k in obj_dict.keys():
-        __find_roots(obj_dict[k], raw_inputs, consider_load=False)
+    for k in task_dict.keys():
+        __find_roots(task_dict[k], raw_inputs, consider_load=False)
+
     for i in raw_inputs:
         i.columns_flow()
+
     # clean up the visited status for run computations
-    for key in obj_dict:
-        obj_dict[key].visited = False
-    return obj_dict
+    for task_id in task_dict:
+        task_dict[task_id].visited = False
+
+    return task_dict
 
 
 def viz_graph(obj):
@@ -197,7 +207,7 @@ def viz_graph(obj):
     return G
 
 
-def run(obj, outputs, replace={}):
+def run(obj, outputs, replace=None):
     """
     Flow the dataframes in the graph to do the data science computations.
 
@@ -206,23 +216,24 @@ def run(obj, outputs, replace={}):
     obj: list
         a list of Python object that defines the nodes
     outputs: list
-        a list of the leaf nodes that we need the final results
+        a list of the leaf node IDs for which to return the final results
     replace: list
         a dict that defines the conf parameters replacement
+
     Returns
     -----
     tuple
         the results corresponding to the outputs list
     """
-
-    obj_dict = get_graph(obj, replace)
+    replace = dict() if replace is None else replace
+    task_dict = build_workflow(obj, replace)
     output_node = Node('unique_output', {})
     # want to save the intermediate results
     output_node.clear_input = False
     results = []
     results_obj = []
     for o in outputs:
-        o_obj = obj_dict[o]
+        o_obj = task_dict[o]
         results_obj.append(o_obj)
         output_node.inputs.append(o_obj)
         o_obj.outputs.append(output_node)
@@ -230,16 +241,19 @@ def run(obj, outputs, replace={}):
     inputs = []
     __find_roots(output_node, inputs, consider_load=True)
     # now clean up the graph, removed the node that is not used for computation
-    for key in obj_dict:
-        current_obj = obj_dict[key]
+    for key in task_dict:
+        current_obj = task_dict[key]
         if not current_obj.visited:
             for i in current_obj.inputs:
                 i.outputs.remove(current_obj)
             current_obj.inputs = []
+
     for i in inputs:
         i.flow()
+
     for r_obj in results_obj:
         results.append(output_node.input_df[r_obj])
+
     # clean the results afterwards
     output_node.input_df = {}
     return tuple(results)
diff --git a/notebook/01_tutorial.ipynb b/notebook/01_tutorial.ipynb
index fcfdc28c..c2a8a3f7 100644
--- a/notebook/01_tutorial.ipynb
+++ b/notebook/01_tutorial.ipynb
@@ -4,8 +4,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### gQuant Tutorial\n",
-    "First import all the necessary modules."
+    "### gquant Tutorial Intro\n",
+    "\n",
+    "gQuant is a quantitative framework built on top of RAPIDS in the Python language. The computing components of gquant are oriented around its plugins and dataframe workflows. Let's begin by importing `nxpd` (Python package for visualization NetworkX graphs using pydot) and the dataframe workflow component of gQuant."
    ]
   },
   {
@@ -14,31 +15,287 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "# Import python libs used throughout\n",
     "import os\n",
-    "\n",
-    "import sys\n",
-    "sys.path.append('..')\n",
-    "\n",
     "import warnings\n",
     "import nxpd\n",
-    "import gquant.dataframe_flow as dff\n",
-    "\n",
-    "warnings.simplefilter(\"ignore\")"
+    "import gquant.dataframe_flow as dff"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In this tutorial, we are going to use gQuant to do a simple quant job. The task is fully described in a yaml file.\n",
+    "In this tutorial, we are going to use gquant to do a simple quant job. The job tasks are listed below:\n",
+    "    1. load csv stock data\n",
+    "    2. filter out the stocks that has average volume smaller than 50\n",
+    "    3. sort the stock symbols and datetime\n",
+    "    4. add rate of return as a feature into the table\n",
+    "    5. In two branches, compute the mean volume and mean return seperately\n",
+    "    6. read the stock symbol name file and join the computed dataframes\n",
+    "    7. output the result in csv files\n",
     "\n",
-    "Here is snippet of the yaml file:"
+    "Using gquant each task can be thought of as a node that operates on cudf dataframes. We formulate a task list or workflow by using these nodes. Below we write the schema for the tasks above."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load csv stock data\n",
+    "task_csvdata = {\n",
+    "    'id': 'node_csvdata',\n",
+    "    'type': 'CsvStockLoader',\n",
+    "    'conf': {\n",
+    "        'path': './data/stock_price_hist.csv.gz'\n",
+    "    },\n",
+    "    'inputs': []\n",
+    "}\n",
+    "\n",
+    "# filter out the stocks that has average volume smaller than 50\n",
+    "task_minVolume = {\n",
+    "    'id': 'node_minVolume',\n",
+    "    'type': 'VolumeFilterNode',\n",
+    "    'conf': {\n",
+    "        'min': 50.0\n",
+    "    },\n",
+    "    'inputs': ['node_csvdata']\n",
+    "}\n",
+    "\n",
+    "# sort the stock symbols and datetime\n",
+    "task_sort = {\n",
+    "    'id': 'node_sort',\n",
+    "    'type': 'SortNode',\n",
+    "    'conf': {\n",
+    "        'keys': ['asset', 'datetime']\n",
+    "    },\n",
+    "    'inputs': ['node_minVolume']\n",
+    "}\n",
+    "\n",
+    "# add rate of return as a feature into the table\n",
+    "task_addReturn = {\n",
+    "    'id': 'node_addReturn',\n",
+    "    'type': 'ReturnFeatureNode',\n",
+    "    'conf': {},\n",
+    "    'inputs': ['node_sort']\n",
+    "}\n",
+    "\n",
+    "# read the stock symbol name file and join the computed dataframes\n",
+    "task_stockSymbol = {\n",
+    "    'id': 'node_stockSymbol',\n",
+    "    'type': 'StockNameLoader',\n",
+    "    'conf': {\n",
+    "        'path': './data/security_master.csv.gz'\n",
+    "    },\n",
+    "    'inputs': []\n",
+    "}\n",
+    "\n",
+    "# In two branches, compute the mean volume and mean return seperately\n",
+    "task_volumeMean = {\n",
+    "    'id': 'node_volumeMean',\n",
+    "    'type': 'AverageNode',\n",
+    "    'conf': {\n",
+    "        'column': 'volume'\n",
+    "    },\n",
+    "    'inputs': ['node_addReturn']\n",
+    "}\n",
+    "\n",
+    "task_returnMean = {\n",
+    "    'id': 'node_returnMean',\n",
+    "    'type': 'AverageNode',\n",
+    "    'conf': {\n",
+    "        'column': 'returns'\n",
+    "    },\n",
+    "    'inputs': ['node_addReturn']\n",
+    "}\n",
+    "\n",
+    "task_leftMerge1 = {\n",
+    "    'id': 'node_leftMerge1',\n",
+    "    'type': 'LeftMergeNode',\n",
+    "    'conf': {\n",
+    "        'column': 'asset'\n",
+    "    },\n",
+    "    'inputs': ['node_volumeMean', 'node_stockSymbol']\n",
+    "}\n",
+    "\n",
+    "task_leftMerge2 = {\n",
+    "    'id': 'node_leftMerge2',\n",
+    "    'type': 'LeftMergeNode',\n",
+    "    'conf': {\n",
+    "        'column': 'asset'\n",
+    "    },\n",
+    "    'inputs': ['node_returnMean', 'node_stockSymbol']\n",
+    "}\n",
+    "\n",
+    "# output the result in csv files\n",
+    "\n",
+    "task_outputCsv1 = {\n",
+    "    'id': 'node_outputCsv1',\n",
+    "    'type': 'OutCsvNode',\n",
+    "    'conf': {\n",
+    "        'path': 'symbol_volume.csv'\n",
+    "    },\n",
+    "    'inputs': ['node_leftMerge1']\n",
+    "}\n",
+    "\n",
+    "task_outputCsv2 = {\n",
+    "    'id': 'node_outputCsv2',\n",
+    "    'type': 'OutCsvNode',\n",
+    "    'conf': {\n",
+    "        'path': 'symbol_returns.csv'\n",
+    "    },\n",
+    "    'inputs': ['node_leftMerge2']\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A task schema defined in python is a dictionary with the following fields: `id`, `type`, `conf`, `inputs`, and `filepath`. Additionally there is a `load` and a `save` field used for running workflows (described later on). The `id` for a given task must be unique within a workflow. Tasks use the `id` field in their `inputs` field for specifying that the output(s) of other tasks are inputs. The `type` is the class of the compute task or plugin. The gquant framework already implements a number of such plugins. These can be found in `gquant.plugin_nodes`. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "class VolumeFilterNode(Node):\n",
+      "\n",
+      "    def columns_setup(self):\n",
+      "        self.required = {\"asset\": \"int64\",\n",
+      "                         \"volume\": \"float64\"}\n",
+      "        self.addition = {\"mean_volume\": \"float64\"}\n",
+      "\n",
+      "    def process(self, inputs):\n",
+      "        \"\"\"\n",
+      "        filter the dataframe based on the min and max values of the average\n",
+      "        volume for each fo the assets.\n",
+      "\n",
+      "        Arguments\n",
+      "        -------\n",
+      "         inputs: list\n",
+      "            list of input dataframes.\n",
+      "        Returns\n",
+      "        -------\n",
+      "        dataframe\n",
+      "        \"\"\"\n",
+      "\n",
+      "        input_df = inputs[0]\n",
+      "        volume_df = input_df[['volume', \"asset\"]].groupby(\n",
+      "                [\"asset\"]).mean().reset_index()\n",
+      "        volume_df.columns = [\"asset\", 'mean_volume']\n",
+      "        merged = input_df.merge(volume_df, on=\"asset\", how='left')\n",
+      "        if 'min' in self.conf:\n",
+      "            minVolume = self.conf['min']\n",
+      "            merged = merged.query('mean_volume >= %f' % (minVolume))\n",
+      "        if 'max' in self.conf:\n",
+      "            maxVolume = self.conf['max']\n",
+      "            merged = merged.query('mean_volume <= %f' % (maxVolume))\n",
+      "        return merged\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import inspect\n",
+    "from gquant.plugin_nodes.transform import VolumeFilterNode\n",
+    "\n",
+    "print(inspect.getsource(VolumeFilterNode))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `conf` field is the configuration field. It is used to parameterize a task. The `conf` can be used to access user set parameters within a plugin (such as `self.conf['min']` in example above). The `filepath` is used to specify a python module where a custom plugin is defined. In another tutorial we go over how to create custom plugins. A custom node schema could look something like:\n",
+    "```\n",
+    "custom_task = {\n",
+    "    'id': 'node_custom_calc',\n",
+    "    'type': 'CustomNode',\n",
+    "    'conf': {},\n",
+    "    'inputs': ['some_other_node'],\n",
+    "    'filepath': 'custom_nodes.py'\n",
+    "}\n",
+    "```\n",
+    "Below we define our complete workflow and visualize it as a graph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "task_list = [\n",
+    "    task_csvdata, task_minVolume, task_sort, task_addReturn,\n",
+    "    task_stockSymbol, task_volumeMean, task_returnMean,\n",
+    "    task_leftMerge1, task_leftMerge2,\n",
+    "    task_outputCsv1, task_outputCsv2]\n",
+    "\n",
+    "task_graph = dff.viz_graph(task_list)\n",
+    "nxpd.draw(task_graph, show='ipynb')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The workflow can now be saved to a yaml file for future re-use."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Workflow File: /tmp/wflow_60eny_2m.yaml\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tempfile import NamedTemporaryFile\n",
+    "\n",
+    "wflow_file = NamedTemporaryFile(prefix='wflow_', suffix='.yaml', delete=False)\n",
+    "wflow_file.close()\n",
+    "dff.save_workflow(task_list, wflow_file.name)\n",
+    "\n",
+    "print('Workflow File: {}'.format(wflow_file.name))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here is a snippet of the contents in the resulting yaml file:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -53,133 +310,226 @@
       "  type: VolumeFilterNode\n",
       "  conf:\n",
       "    min: 50.0\n",
-      "  inputs: \n",
-      "    - node_csvdata\n",
+      "  inputs:\n",
+      "  - node_csvdata\n",
       "- id: node_sort\n",
       "  type: SortNode\n",
       "  conf:\n",
-      "    keys: \n",
-      "      - asset\n",
-      "      - datetime\n",
-      "  inputs: \n",
-      "    - node_minVolume\n",
+      "    keys:\n",
+      "    - asset\n",
+      "    - datetime\n",
+      "  inputs:\n",
+      "  - node_minVolume\n",
       "- id: node_addReturn\n",
       "  type: ReturnFeatureNode\n",
       "  conf: {}\n",
-      "  inputs: \n",
-      "    - node_sort\n",
+      "  inputs:\n",
+      "  - node_sort\n",
       "- id: node_stockSymbol\n",
       "  type: StockNameLoader\n",
       "  conf:\n",
-      "      path: ./data/security_master.csv.gz\n",
-      "  inputs: []\n"
+      "    path: ./data/security_master.csv.gz\n",
+      "  inputs: []\n",
+      "\n"
      ]
     }
    ],
    "source": [
-    "!head -n 29 ../task_example/simple_task.yaml"
+    "N = 29\n",
+    "with open(wflow_file.name) as myfile:\n",
+    "    head = [next(myfile) for x in range(N)]\n",
+    "\n",
+    "print(''.join(head))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The yaml file is describing the computation task by a graph, we can visualize it"
+    "The yaml file describes the computation tasks. We can load it and visualize it as a graph. Note, that since the individual tasks can be parameterized, the overall workflow can be parameterized as well. In this manner the workflow can be reused dynamically. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "obj = dff.load_workflow('../task_example/simple_task.yaml')\n",
-    "G = dff.viz_graph(obj)\n",
-    "nxpd.draw(G, show='ipynb')"
+    "task_list = dff.load_workflow(wflow_file.name)\n",
+    "task_graph = dff.viz_graph(task_list)\n",
+    "nxpd.draw(task_graph, show='ipynb')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "It is easy to read from the graph that this task has following steps:\n",
-    "    1. load csv stock data\n",
-    "    2. filter out the stocks that has average volume smaller than 50\n",
-    "    3. sort the stock symbols and datetime\n",
-    "    4. add rate of return as a feature into the table\n",
-    "    5. In two branches, compute the mean volume and mean return seperately\n",
-    "    6. read the stock symbol name file and join the computed dataframes\n",
-    "    7. output the result in csv files\n",
-    "When building the graph, the column names and types can be computed by traversing the graph without doing the dataframe computations.\n",
-    "It is useful to do column names and types check and find the errors early.\n",
-    "We can see all the input/output dataframe column names and types after the graph is built. E.g. here is the input and output columns for node `node_leftMerge1`"
+    "### Building and running a workflow\n",
+    "\n",
+    "The next step would be to run the workflow. Optionally, we can build the workflow prior to running. This could be useful to inspect the column names and types, validate that the plugins can be instantiated, and check for errors. This can be done by calling `build_workflow` function to traverses the workflow graph without running the dataframe computations. In the example below we inspect the column names and types for the inputs and outputs of the `node_leftMerge` task."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "output df columns {'volume': 'float64', 'asset': 'int64', 'asset_name': 'object'}\n",
-      "input df columns {<gquant.plugin_nodes.transform.averageNode.AverageNode object at 0x7f66433565f8>: {'volume': 'float64', 'asset': 'int64'}, <gquant.plugin_nodes.dataloader.stockNameLoader.StockNameLoader object at 0x7f66433565c0>: {'asset': 'int64', 'asset_name': 'object'}}\n"
+      "Output of build workflow are instances of each task in a dictionary:\n",
+      "{'node_addReturn': <gquant.plugin_nodes.transform.returnFeatureNode.ReturnFeatureNode object at 0x2b3d4af29128>,\n",
+      " 'node_csvdata': <gquant.plugin_nodes.dataloader.csvStockLoader.CsvStockLoader object at 0x2b3d4af29080>,\n",
+      " 'node_leftMerge1': <gquant.plugin_nodes.transform.leftMergeNode.LeftMergeNode object at 0x2b3d4af291d0>,\n",
+      " 'node_leftMerge2': <gquant.plugin_nodes.transform.leftMergeNode.LeftMergeNode object at 0x2b3d4b5e2c18>,\n",
+      " 'node_minVolume': <gquant.plugin_nodes.transform.volumeFilterNode.VolumeFilterNode object at 0x2b3d4af290b8>,\n",
+      " 'node_outputCsv1': <gquant.plugin_nodes.analysis.outCsvNode.OutCsvNode object at 0x2b3d4af29208>,\n",
+      " 'node_outputCsv2': <gquant.plugin_nodes.analysis.outCsvNode.OutCsvNode object at 0x2b3d4af29240>,\n",
+      " 'node_returnMean': <gquant.plugin_nodes.transform.averageNode.AverageNode object at 0x2b3d4af29198>,\n",
+      " 'node_sort': <gquant.plugin_nodes.transform.sortNode.SortNode object at 0x2b3d4af290f0>,\n",
+      " 'node_stockSymbol': <gquant.plugin_nodes.dataloader.stockNameLoader.StockNameLoader object at 0x2b3d4afb5128>,\n",
+      " 'node_volumeMean': <gquant.plugin_nodes.transform.averageNode.AverageNode object at 0x2b3d4af29160>}\n",
+      "\n",
+      "\n",
+      "Input columns in incoming dataframes:\n",
+      "{<gquant.plugin_nodes.dataloader.stockNameLoader.StockNameLoader object at 0x2b3d4afb5128>: {'asset': 'int64',\n",
+      "                                                                                             'asset_name': 'object'},\n",
+      " <gquant.plugin_nodes.transform.averageNode.AverageNode object at 0x2b3d4af29160>: {'asset': 'int64',\n",
+      "                                                                                    'volume': 'float64'}}\n",
+      "\n",
+      "\n",
+      "Output columns in outgoing dataframe:\n",
+      "{'asset': 'int64', 'asset_name': 'object', 'volume': 'float64'}\n",
+      "\n",
+      "\n",
+      "\n"
      ]
     }
    ],
    "source": [
-    "obj_dict = dff.get_graph(obj, {})\n",
-    "print('output df columns', obj_dict['node_leftMerge1'].output_columns)\n",
-    "print('input df columns', obj_dict['node_leftMerge1'].input_columns)"
+    "from pprint import pprint\n",
+    "\n",
+    "task_dict = dff.build_workflow(task_list)\n",
+    "print('Output of build workflow are instances of each task in a dictionary:')\n",
+    "pprint(task_dict)\n",
+    "\n",
+    "lmerge1_task_instance = task_dict['node_leftMerge1']\n",
+    "\n",
+    "print('\\n\\nInput columns in incoming dataframes:')\n",
+    "pprint(lmerge1_task_instance.input_columns)\n",
+    "\n",
+    "print('\\n\\nOutput columns in outgoing dataframe:')\n",
+    "pprint(lmerge1_task_instance.output_columns)\n",
+    "\n",
+    "print('\\n\\n')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To do the computation, we just specify the output nodes name"
+    "Building the workflow is optional, because the `build_workflow` function is called within `run`, but it is useful for inspection. We use the `run` function to run the dataframe computations. The required `run` function arguments are a task list and outputs list. The `run` also takes an optional `replace` argument which is used and explained later on."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
-    "action = \"load\" if os.path.isfile('./.cache/node_csvdata.hdf5') else \"save\"\n",
-    "o = dff.run(obj, outputs=['node_outputCsv1', 'node_outputCsv2'],\n",
-    "            replace={'node_csvdata': {action: True}})"
+    "outlist = ['node_csvdata', 'node_outputCsv1', 'node_outputCsv2']\n",
+    "\n",
+    "# o = dff.run(task_list, outputs=outlist, replace=replace_spec)\n",
+    "# csv1_df, csv2_df = dff.run(task_list, outputs=outlist)\n",
+    "with warnings.catch_warnings():\n",
+    "    warnings.simplefilter('ignore', category=UserWarning)\n",
+    "    csvdata_df, csv1_df, csv2_df = dff.run(task_list, outputs=outlist)"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 10,
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Outputs Csv1 Dataframe:\n",
+      "     asset              volume  asset_name\n",
+      "0  869584   673.6252347192939         LPT\n",
+      "1  869589  110.45606585788563        DSLV\n",
+      "2  869590   66.60725338491311        BPTH\n",
+      "3  869592   56.04176626826026          SP\n",
+      "4  869349    91.1619912790699        VIIX\n",
+      "5  869357   307.7649913344884        USLV\n",
+      "6  869358  487.50996732026226         UVE\n",
+      "7  869363  149.03844827586232        SNOW\n",
+      "8  869368  130.89174311926593        AMBR\n",
+      "9  869369  149.52366548042716         IBP\n",
+      "[3674 more rows]\n",
+      "\n",
+      "Outputs Csv2 Dataframe:\n",
+      "     asset                  returns  asset_name\n",
+      "0  869584    0.0003694185044968794         LPT\n",
+      "1  869589     0.001077215924445622        DSLV\n",
+      "2  869590     0.005320585829942715        BPTH\n",
+      "3  869592    0.0005018748359261746          SP\n",
+      "4  869349       0.0047172681011212        VIIX\n",
+      "5  869357      0.00572973978564648        USLV\n",
+      "6  869358    0.0013285777584282489         UVE\n",
+      "7  869363  -2.8580346399647086e-05        SNOW\n",
+      "8  869368    -0.001582324338745823        AMBR\n",
+      "9  869369    0.0017413617080852127         IBP\n",
+      "[3674 more rows]\n",
+      "\n",
+      "Csv Files produced:\n",
+      "\n",
+      "./symbol_volume.csv\n",
+      "./symbol_returns.csv\n"
+     ]
+    }
+   ],
    "source": [
-    "We can see it generates two resulting csv files: \n",
+    "print('Outputs Csv1 Dataframe:\\n{}'.format(csv1_df))\n",
+    "print('\\nOutputs Csv2 Dataframe:\\n{}'.format(csv2_df))\n",
     "\n",
+    "print('\\nCsv Files produced:\\n')\n",
+    "!find . -iname \"*symbol*\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Above, we can see that two resulting csv files were generated:\n",
     "- symbol_returns.csv\n",
-    "- symbol_volume.csv\n",
-    "\n",
-    "The nice thing about using graph is that we can evaluate a sub-graph. For example, we are interested in the result in `node_volumeMean` only "
+    "- symbol_volume.csv"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The nice thing about using a workflow task graph is that we can evaluate a sub-graph. For example, if are interested in the `node_volumeMean` result only, we can run the workflow tasks only relevant for that computation. Additionally, if we do not want to re-run tasks we can use the `replace` argument of the `run` function with a `load` option. The `replace` argument needs to be a dictionary where each key is the task/node id. The values are a replacement task-spec dictionary i.e. where each key is a spec overload and value is what to overload with. In the example below instead of re-running `node_csvdata` that loads `csv` into a `cudf` dataframe, we use its dataframe output above to load from."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -187,131 +537,234 @@
      "output_type": "stream",
      "text": [
       "   asset              volume\n",
-      "0    631   350.2600259993504\n",
-      "1    914   266.2237735849057\n",
-      "2   1404   2073.529167746953\n",
-      "3   1544   80.65922330097064\n",
-      "4   1545  18922.826861182217\n"
+      "0    631  350.26002599934947\n",
+      "1    914  266.22377358490553\n",
+      "2   1404   2073.529167746952\n",
+      "3   1544   80.65922330097092\n",
+      "4   1545   18922.82686118217\n"
      ]
     }
    ],
    "source": [
-    "o = dff.run(obj, outputs=['node_volumeMean'],\n",
-    "            replace={'node_csvdata': {\"load\": True}})\n",
+    "replace_spec = {\n",
+    "    'node_csvdata': {\n",
+    "        'load': csvdata_df,\n",
+    "        'save': True\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "with warnings.catch_warnings():\n",
+    "    warnings.simplefilter('ignore', category=UserWarning)\n",
+    "    (volmean_df,) = dff.run(\n",
+    "        task_list,\n",
+    "        outputs=['node_volumeMean'],\n",
+    "        replace=replace_spec)\n",
     "\n",
-    "print(o[0].head())"
+    "print(volmean_df.head())"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "sometimes, we want to evalute some node multiple times, it doesn't make sense to run from the very beginning. We can save the check points for any of the note in the graph. For example, we can save the `node_returnMean` result"
+    "As a convenience we can save the check points for any of the nodes in the graph on disk and re-load. This is done by specifying boolean `True` for the save option. In the example above the `replace_spec` directs `run` to save on disk for the `node_csvdata`. If `load` was boolean then the data would be loaded from disk presuming the data was saved to disk in a prior run. The default directory for saving is `<current_workdir>/.cache/<node_id>.hdf5`. PyTables is required for the saving to disk functionality. Install via:\n",
+    "```\n",
+    "conda install -c anaconda pytables\n",
+    "```\n",
+    "\n",
+    "The replace spec is also used for overriding parameters in the tasks. For example, in the task `node_minVolume` if instead of `50.0` we wanted to use `40.0` our replace spec would be:\n",
+    "```\n",
+    "replace_spec = {\n",
+    "    'node_minVolume': {\n",
+    "        'conf': {\n",
+    "            'min': 40.0\n",
+    "        }\n",
+    "    },\n",
+    "    'some_task': etc...\n",
+    "}\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If we want to evalute a particular task multiple times it does not make sense to re-run everything from the very beginning. For example, we can save the `node_returnMean` result on disk."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Return Mean Dataframe:\n",
+      "    asset                 returns\n",
+      "0    631   2.579372358333649e-05\n",
+      "1    914  -0.0008932574948235614\n",
+      "2   1404   0.0004232514430167562\n",
+      "3   1544   0.0011525606145957488\n",
+      "4   1545   0.0007839569686931374\n",
+      "5   1551   0.0010664550162285712\n",
+      "6   1556   0.0004030030702918709\n",
+      "7   1562   0.0013682239808026357\n",
+      "8   1565    0.001525718185249225\n",
+      "9   1568   0.0022582282008917287\n",
+      "[3674 more rows]\n"
+     ]
+    }
+   ],
    "source": [
-    "o = dff.run(obj, outputs=['node_returnMean'],\n",
-    "            replace={'node_csvdata': {\"load\": True},\n",
-    "                     'node_returnMean': {\"save\": True}})"
+    "replace_spec = {\n",
+    "    'node_csvdata': {\n",
+    "        'load': True\n",
+    "    },\n",
+    "    'node_returnMean': {\n",
+    "        'save': True\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "with warnings.catch_warnings():\n",
+    "    warnings.simplefilter('ignore', category=UserWarning)\n",
+    "    (returnmean_df,) = dff.run(task_list, outputs=['node_returnMean'], replace=replace_spec)\n",
+    "\n",
+    "print('Return Mean Dataframe:\\n{}'.format(returnmean_df))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Then we can load it from the saved file for later nodes to evaluate"
+    "Then we can load the `returnmean_df` from the saved file and evaluate only tasks that we are interested in."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 0 ns, sys: 0 ns, total: 0 ns\n",
-      "Wall time: 55.6 µs\n",
-      "CPU times: user 0 ns, sys: 0 ns, total: 0 ns\n",
-      "Wall time: 15 µs\n"
+      "Using in-memory dataframes for load:\n",
+      "CPU times: user 48.6 ms, sys: 13.2 ms, total: 61.8 ms\n",
+      "Wall time: 363 ms\n",
+      "\n",
+      "Using cached dataframes on disk for load:\n",
+      "CPU times: user 58.5 ms, sys: 2.94 ms, total: 61.4 ms\n",
+      "Wall time: 121 ms\n",
+      "\n",
+      "Re-running dataframes calculations instead of using load:\n",
+      "CPU times: user 12.6 s, sys: 3.24 s, total: 15.8 s\n",
+      "Wall time: 46.7 s\n"
      ]
     }
    ],
    "source": [
-    "%time\n",
-    "o = dff.run(obj, outputs=['node_outputCsv2'],\n",
-    "            replace={'node_csvdata': {\"load\": True},\n",
-    "                     'node_returnMean': {\"load\": True}})\n",
-    "\n",
-    "%time\n",
-    "o = dff.run(obj, outputs=['node_outputCsv2'],\n",
-    "            replace={'node_csvdata': {\"load\": True}})"
+    "warnings.simplefilter('ignore', category=UserWarning)\n",
+    "\n",
+    "print('Using in-memory dataframes for load:')\n",
+    "replace_spec = {\n",
+    "    'node_csvdata': {\n",
+    "        'load': csvdata_df\n",
+    "    },\n",
+    "    'node_returnMean': {\n",
+    "        'load': returnmean_df\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "%time out_tuple = dff.run(task_list, outputs=['node_outputCsv2'], replace=replace_spec)\n",
+    "\n",
+    "print('\\nUsing cached dataframes on disk for load:')\n",
+    "replace_spec = {\n",
+    "    'node_csvdata': {\n",
+    "        'load': True\n",
+    "    },\n",
+    "    'node_returnMean': {\n",
+    "        'load': True\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "%time out_tuple = dff.run(task_list, outputs=['node_outputCsv2'], replace=replace_spec)\n",
+    "\n",
+    "print('\\nRe-running dataframes calculations instead of using load:')\n",
+    "replace_spec = {\n",
+    "    'node_csvdata': {\n",
+    "        'load': True\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "%time out_tuple = dff.run(task_list, outputs=['node_outputCsv2'], replace=replace_spec)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "compare with the time of running from beginning, we save a lot of time. It is ideal for the iterations type of workflow."
+    "Above we are comparing the various load approaches: in-memory, from disk, and not loading at all. When working interactively, or in situations requiring iterative and explorative workflows, we save significant amount of time by just re-loading data we do not need to recalculate."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The intermediate result can be cached into the variables too. It saves the disk I/O time"
+    "An idiomatic way to save data, if not on disk, or load data, if present on disk, is demonstrated below."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 0 ns, sys: 0 ns, total: 0 ns\n",
-      "Wall time: 48.9 µs\n",
-      "CPU times: user 0 ns, sys: 0 ns, total: 0 ns\n",
-      "Wall time: 13.8 µs\n"
+      "CPU times: user 60.1 ms, sys: 6.02 ms, total: 66.1 ms\n",
+      "Wall time: 73.6 ms\n"
      ]
     }
    ],
    "source": [
-    "cached = dff.run(obj, outputs=['node_returnMean'],\n",
-    "                 replace={'node_csvdata': {\"load\": True}})\n",
-    "\n",
-    "%time\n",
-    "o = dff.run(obj, outputs=['node_outputCsv2'],\n",
-    "            replace={'node_csvdata': {\"load\": True},\n",
-    "                     'node_returnMean': {\"load\": cached[0]}})\n",
-    "\n",
-    "%time\n",
-    "o = dff.run(obj, outputs=['node_outputCsv2'],\n",
-    "            replace={'node_csvdata': {\"load\": True},\n",
-    "                     'node_returnMean': {\"load\": True}})"
+    "loadsave_csvdata = \\\n",
+    "    'load' if os.path.isfile('./.cache/node_csvdata.hdf5') else 'save'\n",
+    "loadsave_returnmean = \\\n",
+    "    'load' if os.path.isfile('./.cache/node_returnMean.hdf5') else 'save'\n",
+    "\n",
+    "replace_spec = {\n",
+    "    'node_csvdata': {\n",
+    "        loadsave_csvdata: True\n",
+    "    },\n",
+    "    'node_returnMean': {\n",
+    "        loadsave_returnmean: True\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "%time out_tuple = dff.run(task_list, outputs=['node_outputCsv2'], replace=replace_spec)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "# Clean up\n",
+    "\n",
+    "# Remove temporary workflow file.\n",
+    "os.unlink(wflow_file.name)"
+   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "py36-rapids",
    "language": "python",
-   "name": "python3"
+   "name": "py36-rapids"
   },
   "language_info": {
    "codemirror_mode": {
diff --git a/notebook/03_simple_dask_example.ipynb b/notebook/03_simple_dask_example.ipynb
index a21dc90b..9e01a210 100644
--- a/notebook/03_simple_dask_example.ipynb
+++ b/notebook/03_simple_dask_example.ipynb
@@ -9,7 +9,7 @@
     "import sys\n",
     "sys.path.append('..')\n",
     "\n",
-    "from gquant.dataframe_flow import run, load_workflow, viz_graph, get_graph\n",
+    "from gquant.dataframe_flow import run, load_workflow, viz_graph\n",
     "import nxpd\n",
     "from nxpd import draw"
    ]
diff --git a/notebook/04_portfolio_trade.ipynb b/notebook/04_portfolio_trade.ipynb
index 678ce4ea..118ed483 100644
--- a/notebook/04_portfolio_trade.ipynb
+++ b/notebook/04_portfolio_trade.ipynb
@@ -28,10 +28,11 @@
     "sys.path.append('..')\n",
     "\n",
     "import warnings\n",
-    "from gquant.dataframe_flow import run, load_workflow, viz_graph, get_graph, Node\n",
+    "from gquant.dataframe_flow import run, load_workflow, viz_graph, Node\n",
     "import nxpd\n",
     "import ipywidgets as widgets\n",
     "from nxpd import draw\n",
+    "import os\n",
     "\n",
     "warnings.simplefilter(\"ignore\")"
    ]
@@ -56,7 +57,7 @@
        "<td style=\"vertical-align: top; border: 0px solid white\">\n",
        "<h3>Client</h3>\n",
        "<ul>\n",
-       "  <li><b>Scheduler: </b>tcp://127.0.0.1:37230\n",
+       "  <li><b>Scheduler: </b>tcp://127.0.0.1:33374\n",
        "  <li><b>Dashboard: </b><a href='http://127.0.0.1:8787/status' target='_blank'>http://127.0.0.1:8787/status</a>\n",
        "</ul>\n",
        "</td>\n",
@@ -72,7 +73,7 @@
        "</table>"
       ],
       "text/plain": [
-       "<Client: scheduler='tcp://127.0.0.1:37230' processes=8 cores=8>"
+       "<Client: scheduler='tcp://127.0.0.1:33374' processes=8 cores=8>"
       ]
      },
      "execution_count": 2,
@@ -312,12 +313,14 @@
     }
    ],
    "source": [
+    "action = \"load\" if os.path.isfile('./.cache/node_csvdata.hdf5') else \"save\"\n",
     "o_gpu = run(graph_obj,\n",
     "            outputs=['node_sharpeRatio', 'node_cumlativeReturn',\n",
     "                     'node_csvdata', 'node_sort2'],\n",
     "            replace={'node_filterValue': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n",
     "                                                   {\"column\": \"returns_max\", \"max\": max_rate},\n",
-    "                                                   {\"column\": \"returns_min\", \"min\": min_rate}]}})\n",
+    "                                                   {\"column\": \"returns_min\", \"min\": min_rate}]},\n",
+    "                     'node_csvdata': {action: True}})\n",
     "\n",
     "gpu_input_cached = o_gpu[2]\n",
     "strategy_cached = o_gpu[3]"
@@ -368,7 +371,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f84223f6ce41453ea4aa43e5b899e45d",
+       "model_id": "a62a5d40fd9b4294ae1eeb67f6dc0103",
        "version_major": 2,
        "version_minor": 0
       },
@@ -432,20 +435,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "distributed.utils_perf - WARNING - full garbage collections took 15% CPU time recently (threshold: 10%)\n",
-      "distributed.utils_perf - WARNING - full garbage collections took 15% CPU time recently (threshold: 10%)\n",
-      "distributed.utils_perf - WARNING - full garbage collections took 16% CPU time recently (threshold: 10%)\n",
-      "distributed.utils_perf - WARNING - full garbage collections took 16% CPU time recently (threshold: 10%)\n",
-      "distributed.utils_perf - WARNING - full garbage collections took 16% CPU time recently (threshold: 10%)\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -456,7 +448,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "99a3836a67ae495988d195cf9ee725b4",
+       "model_id": "59bae21e36c64541b95fc4bfba160815",
        "version_major": 2,
        "version_minor": 0
       },
@@ -492,7 +484,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
@@ -500,8 +492,8 @@
      "output_type": "stream",
      "text": [
       "cumulative return 6815 22\n",
-      "CPU times: user 29.1 s, sys: 4.86 s, total: 34 s\n",
-      "Wall time: 2.51 s\n"
+      "CPU times: user 29 s, sys: 4.85 s, total: 33.9 s\n",
+      "Wall time: 2.54 s\n"
      ]
     }
    ],
@@ -548,7 +540,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We run this in V100 Tesla GPU and Intel(R) Xeon(R) Gold 6148 CPU. It takes 73 seconds to run in the CPU and 4 seconds to run in the GPU. We get 18x speed up by using GPU dataframe. Note, the input nodes load the dataframes from the cache variables to save the disk IO time. \n",
+    "We run this in V100 Tesla GPU and Intel(R) Xeon(R) Gold 6148 CPU. It takes 73 seconds to run in the CPU and 4 seconds to run in the GPU. We get 67x speed up by using GPU dataframe. Note, the input nodes load the dataframes from the cache variables to save the disk IO time. \n",
     "\n",
     "gQuant distributed computation\n",
     "Run this toy example in Dask distributed environment is super easy as gQuant operates at the dataframe level. We just need to swap cudf Dataframe to dask_cudf Dataframe. First we split the large dataframe into small pieces to be loaded by different workers in the cluster (this step is noly need if the dataset is not prepared yet)"
@@ -575,7 +567,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
@@ -588,7 +580,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "672c8b1390f5423b877f0bc4f081f593",
+       "model_id": "cdcb169b74db474e8bd1852a66f2ad7e",
        "version_major": 2,
        "version_minor": 0
       },
@@ -626,13 +618,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c1572f5e583442c19cf7eaf24df8a9fb",
+       "model_id": "9fce71658b9a484e810430895f397f1b",
        "version_major": 2,
        "version_minor": 0
       },
diff --git a/notebook/05_customize_nodes.ipynb b/notebook/05_customize_nodes.ipynb
index 4d733b2f..d92c67ea 100644
--- a/notebook/05_customize_nodes.ipynb
+++ b/notebook/05_customize_nodes.ipynb
@@ -4,26 +4,22 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Customized your own nodes in gQuant\n",
+    "### Customize your own GPU Kernels in gquant\n",
     "\n",
-    "In previous blog, we showed how to use gQuant to accelerate quantitive finance workflows in the GPU easily. The accleration in GPU is turned on by using GPU cuDF dataframe in the computation graph. cuDF is an on going project that a few dataframe methods haven't been implemented yet. Sometimes the quantitative work needs some special logics to manipulate the data that no direct support at cuDF dataframe is available yet. One solution is to build customized GPU kernels to implement them.\n",
+    "The gquant framework is designed to accelerate quantitive finance workflows on the GPU. The acceleration on GPU is facilitated by using cuDF dataframes in the computation graph. The cuDF project is a continously evolving library that provides a pandas-like API. When the quantitative work needs customized logic to manipulate the data, and there are no direct methods within cuDF to support this logic, one solution is to build customized GPU kernels to implement them.\n",
     "\n",
-    "This blog will show how to use different methods to implement customized GPU kernels in Python\n",
-    "\n",
-    "### Enviroment setup\n",
-    "\n",
-    "Load following necessary Python modules"
+    "The code and examples below illustrate a variety of approaches to implement customized GPU kernels in Python."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
+    "# Load necessary Python modules\n",
     "import sys\n",
-    "sys.path.append('..')\n",
-    "from gquant.dataframe_flow import run, load_workflow, viz_graph, get_graph, Node\n",
+    "from gquant.dataframe_flow import run, viz_graph, Node\n",
     "import nxpd\n",
     "import cudf\n",
     "import numpy as np\n",
@@ -44,12 +40,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "def verify(ground_truth, computed):\n",
-    "    max_difference = cudf.sqrt((ground_truth - computed)**2).max()\n",
+    "    max_difference = (ground_truth - computed).abs().max()\n",
+    "    # print('Max Difference: {}'.format(max_difference))\n",
     "    assert(max_difference < 1e-8)\n",
     "    return max_difference"
    ]
@@ -58,15 +55,15 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### A toy Problem, compute the distance of points to the origin\n",
-    "The toy problem is to compute the distance of the list of points in 2-D space to the origin. \n",
+    "### Example Problem: Calculating the distance of points to the origin\n",
     "\n",
-    "We create a source Node in the graph that generate a cuDF dataframe containing 1000 random points."
+    "The sample problem is to take a list of points in 2-D space and compute their distance to the origin.\n",
+    "We start by creating a source `Node` in the graph that generate a cuDF dataframe containing 1000 random points."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -74,8 +71,8 @@
     "\n",
     "    def columns_setup(self,):\n",
     "        self.required = {}\n",
-    "        self.addition = {\"x\": \"float64\",\n",
-    "                         \"y\": \"float64\"}\n",
+    "        self.addition = {'x': 'float64',\n",
+    "                         'y': 'float64'}\n",
     "\n",
     "    def process(self, inputs):\n",
     "        df = cudf.DataFrame()\n",
@@ -88,25 +85,25 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The distance can be computed via cuDF methods. Following is to create a DistanceNode that is used to add a distance column to the output dataframe. We use it as a ground truth to verify results later"
+    "The distance can be computed via cuDF methods. We define the DistanceNode to calculate the distance and add a `distance_cudf` column to the output dataframe. We use that as the ground truth to compare and verify results later."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
     "class DistanceNode(Node):\n",
     "\n",
     "    def columns_setup(self,):\n",
-    "        self.required = {\"x\": \"float64\",\n",
-    "                         \"y\": \"float64\"}\n",
-    "        self.addition = {\"distance\": \"float64\"}\n",
+    "        self.required = {'x': 'float64',\n",
+    "                         'y': 'float64'}\n",
+    "        self.addition = {'distance_cudf': 'float64'}\n",
     "\n",
     "    def process(self, inputs):\n",
     "        df = inputs[0]\n",
-    "        df['distance'] = (df['x']**2 + df['y']**2).sqrt()\n",
+    "        df['distance_cudf'] = (df['x']**2 + df['y']**2).sqrt()\n",
     "        return df"
    ]
   },
@@ -114,127 +111,142 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Having these two nodes, we can construct a simple graph to compute the distance."
+    "Having these two nodes, we can construct a simple task graph to compute the distance."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "input_node = {\"id\": \"points\",\n",
-    "              \"type\": PointNode,\n",
-    "              \"conf\": {},\n",
-    "              \"inputs\": []}\n",
-    "distance_node = {\"id\": \"distance_by_dataframe\",\n",
-    "                 \"type\": DistanceNode,\n",
-    "                 \"conf\": {},\n",
-    "                 \"inputs\": [\"points\"]}\n",
-    "G = viz_graph([input_node, distance_node])\n",
-    "draw(G, show='ipynb')"
+    "input_node = {\n",
+    "    'id': 'points',\n",
+    "    'type': PointNode,\n",
+    "    'conf': {},\n",
+    "    'inputs': []}\n",
+    "\n",
+    "cudf_distance_node = {\n",
+    "    'id': 'distance_by_cudf',\n",
+    "    'type': DistanceNode,\n",
+    "    'conf': {},\n",
+    "    'inputs': ['points']}\n",
+    "\n",
+    "task_list = [input_node, cudf_distance_node]\n",
+    "task_graph = viz_graph(task_list)\n",
+    "draw(task_graph, show='ipynb')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Evaluate the output node in the graph, we get the distances:"
+    "The next step is to run the task graph to obtain the distances. The output is identified by the `id` of the distance node:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "                     x                    y             distance\n",
-      "0  0.24744864211461703   0.8420559661943564   0.8776611422911914\n",
-      "1   0.1543558871885372   0.4424360528069907  0.46858873304123594\n",
-      "2   0.3635119940625038   0.3568795742429829   0.5094153514953692\n",
-      "3   0.7150110593476766   0.4128603315583932   0.8256479082296478\n",
-      "4   0.3209373463254228   0.4751279408906893   0.5733649278438914\n",
-      "5   0.7138497382915616   0.6844185528130492   0.9889439844064171\n",
-      "6   0.8851171935524784  0.13169773091112058   0.8948612957600488\n",
-      "7   0.4820764687348812  0.36869068683647144   0.6069024174180244\n",
-      "8   0.4802436552114432    0.618830235076933   0.7833165568377958\n",
-      "9   0.4720569876068379  0.10552922248129881   0.4837088135913483\n",
+      "                     x                    y       distance_cudf\n",
+      "0   0.6723520442470782   0.9852608399140459    1.19281020873874\n",
+      "1  0.17910433988109542   0.5148459667925289  0.5451098367180478\n",
+      "2   0.5257041049202444  0.10985072301370735  0.5370586441689861\n",
+      "3  0.26735267785465155   0.5926111721129101  0.6501272611336109\n",
+      "4   0.9506848567426767   0.6139323276570774  1.1316866173028117\n",
+      "5  0.28852689302050794   0.5020580364068686  0.5790596168934493\n",
+      "6   0.5348492125065254   0.8500743192319166   1.004335615387833\n",
+      "7   0.6109030362226028  0.46907622241986024  0.7702175160989789\n",
+      "8   0.4527043048265347   0.6433244451659434  0.7866432033371579\n",
+      "9  0.04191743601279396   0.9407673034333391   0.941700690586517\n",
       "[990 more rows]\n"
      ]
     }
    ],
    "source": [
-    "o = run([input_node, distance_node], outputs=['distance_by_dataframe'], replace={})\n",
-    "print(o[0])"
+    "(out_df,) = run(task_list, outputs=['distance_by_cudf'])\n",
+    "print(out_df)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Customized Kernel by Numba library\n",
-    "\n",
-    "Numba is an excellent python library that accelerates the numerical computations. Most importantly, Numba supports CUDA GPU programming by directly compiling a restricted subset of Python code into CUDA kernels and device functions following the CUDA execution model.\n",
-    "cuDF series can be converted to GPU arrays that the Numba library recognizes.\n",
+    "### Customized Kernel with Numba library\n",
     "\n",
-    "The Numba GPU kernel is written in Python and translated into GPU code in the runtime. We just need to decorate the Python function with `@cuda.jit`."
+    "Numba is an excellent python library used for accelerating numerical computations. Numba supports CUDA GPU programming by directly compiling a restricted subset of Python code into CUDA kernels and device functions. The Numba GPU kernel is written in Python and translated (JIT just-in-time compiled) into GPU code at runtime. This is achieved by decorating a Python function with `@cuda.jit`."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
     "@cuda.jit\n",
     "def distance_kernel(x, y, distance, array_len):\n",
-    "    i = cuda.threadIdx.x + cuda.blockIdx.x * cuda.blockDim.x\n",
-    "    if i < array_len:\n",
-    "        distance[i] = math.sqrt(x[i]**2 + y[i]**2)"
+    "    # ii - overall thread index\n",
+    "    ii = cuda.threadIdx.x + cuda.blockIdx.x * cuda.blockDim.x\n",
+    "    if ii < array_len:\n",
+    "        distance[ii] = math.sqrt(x[ii]**2 + y[ii]**2)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Define a Node that calls this Numba kernel to compute the distance and save the result into `distance_numba` column"
+    "A cuDF series can be converted to GPU arrays compatible with the Numba library via `to_gpu_array` API. The next step is to define a Node that calls this Numba kernel to compute the distance and save the result into `distance_numba` column in the output dataframe."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
+    "from librmm_cffi import librmm as rmm\n",
+    "\n",
+    "\n",
     "class NumbaDistanceNode(Node):\n",
     "\n",
     "    def columns_setup(self,):\n",
-    "        self.required = {\"x\": \"float64\",\n",
-    "                         \"y\": \"float64\"}\n",
-    "        self.addition = {\"distance_numba\": \"float64\"}\n",
+    "        self.required = {'x': 'float64',\n",
+    "                         'y': 'float64'}\n",
+    "        self.addition = {'distance_numba': 'float64'}\n",
     "        self.delayed_process = True\n",
     "\n",
     "    def process(self, inputs):\n",
     "        df = inputs[0]\n",
     "        number_of_threads = 16\n",
-    "        number_of_blocks = (len(df) - 1)//number_of_threads + 1\n",
-    "        df['distance_numba'] = 0.0\n",
-    "        distance_kernel[(number_of_blocks,), (number_of_threads,)](df['x'].data.to_gpu_array(), df['y'].data.to_gpu_array(), df['distance_numba'].data.to_gpu_array(), len(df))\n",
+    "        number_of_blocks = ((len(df) - 1)//number_of_threads) + 1\n",
+    "        # Inits device array by setting 0 for each index.\n",
+    "        # df['distance_numba'] = 0.0\n",
+    "        # darr = rmm.device_array(len(df))\n",
+    "        darr = cuda.device_array(len(df))\n",
+    "        distance_kernel[(number_of_blocks,), (number_of_threads,)](\n",
+    "            df['x'].to_gpu_array(),\n",
+    "            df['y'].to_gpu_array(),\n",
+    "            darr,\n",
+    "            len(df))\n",
+    "        # df['distance_numba'].to_gpu_array()\n",
+    "        df['distance_numba'] = darr\n",
     "        return df"
    ]
   },
@@ -242,26 +254,30 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Node, we added `self.delayed_process = True` flag in the `columns_setup`. This is necesary if we want to include this node into the Dask computation graph. Normally, the `dask_cuDF` dataframe doesn't support GPU customized kernels. We can use `to_delayed` and `from_delayed` low level interface to work around it. If the flag is added, the gQuant handles this automatically under the hood.\n",
-    "\n",
-    "\n",
+    "The `self.delayed_process = True` flag in the `columns_setup` is necesary to enable the logic in the `Node` class for handling `dask_cudf` dataframes in order to use Dask (for distributed computation i.e. multi-gpu in examples later on). The `dask_cudf` dataframe does not support GPU customized kernels directly. The `to_delayed` and `from_delayed` low level interfaces of `dask_cudf` enable this support. The gquant framework handles `dask_cudf` dataframes automatically under the hood when we set this flag."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
     "### Customized Kernel by CuPy library\n",
     "\n",
-    "Numba is to compile the Python code into GPU code in the runtime. It has some limitations to use it. And it adds some overhead using it too. \n",
-    "When the Python process calls the Numba kernel for the first time, it take some CPU time to compile the Python code. If advanced features are needed and lattency is important, CuPy can be used to compile raw C/C++ CUDA code.\n",
+    "CuPy is an alternative to Numba. Numba JIT compiles Python code into GPU device code at runtime. There are some limitations in how Numba can be used as well as JIT compilation latency overhead. When a Python process calls a Numba GPU kernel for the first time Numba has to compile the Python code, and each time a new Python process is started the GPU kernel has to be recompiled. If advanced features of CUDA are needed and latency is important, CuPy is an alternative library that can be used to compile C/C++ CUDA code. CuPy caches the GPU device code on disk (default location `$(HOME)/.cupy/kernel_cache` which can be changed via `CUPY_CACHE_DIR` environment variable) thus eliminating compilation latency for subsequent Python processes.\n",
     "\n",
-    "`CuPy` GPU kernel is esentially a C/C++ GPU kernel, here is one example:"
+    "`CuPy` GPU kernel is esentially a C/C++ GPU kernel. Below we define the `compute_distance` kernel using `CuPy`:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
     "raw_kernel = cupy.RawKernel(r'''\n",
     "    extern \"C\" __global__\n",
-    "    void compute_distance(const double* x, const double* y, double* distance, int arr_len) {\n",
+    "    void compute_distance(const double* x, const double* y,\n",
+    "            double* distance, int arr_len) {\n",
     "        int tid = blockDim.x * blockIdx.x + threadIdx.x;\n",
     "        if (tid < arr_len){\n",
     "        distance[tid] = sqrt(x[tid]*x[tid] + y[tid]*y[tid]);\n",
@@ -274,31 +290,34 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Define a Node that calls this CuPy kernel to compute the distance and save the results into `distance_cupy` column"
+    "Using gquant we can now define a Node that calls this CuPy kernel to compute the distance and save the results into `distance_cupy` column of a `cudf` dataframe."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
     "class CupyDistanceNode(Node):\n",
     "\n",
     "    def columns_setup(self,):\n",
-    "        self.required = {\"x\": \"float64\",\n",
-    "                         \"y\": \"float64\"}\n",
-    "        self.addition = {\"distance_cupy\": \"float64\"}\n",
+    "        self.required = {'x': 'float64',\n",
+    "                         'y': 'float64'}\n",
+    "        self.addition = {'distance_cupy': 'float64'}\n",
     "        self.delayed_process = True\n",
     "\n",
     "    def process(self, inputs):\n",
     "        df = inputs[0]\n",
-    "        cupy_x = cupy.asarray(df['x'].data.to_gpu_array())\n",
-    "        cupy_y = cupy.asarray(df['y'].data.to_gpu_array())\n",
+    "        # cupy_x = cupy.asarray(df['x'].to_gpu_array())\n",
+    "        # cupy_y = cupy.asarray(df['y'].to_gpu_array())\n",
+    "        cupy_x = cupy.asarray(df['x'])\n",
+    "        cupy_y = cupy.asarray(df['y'])\n",
     "        number_of_threads = 16\n",
     "        number_of_blocks = (len(df) - 1)//number_of_threads + 1\n",
-    "        dis = cupy.arange(len(df), dtype=cupy.float64)\n",
-    "        raw_kernel((number_of_blocks,), (number_of_threads,), (cupy_x, cupy_y, dis, len(df)))\n",
+    "        dis = cupy.ndarray(len(df), dtype=cupy.float64)\n",
+    "        raw_kernel((number_of_blocks,), (number_of_threads,),\n",
+    "                   (cupy_x, cupy_y, dis, len(df)))\n",
     "        df['distance_cupy'] = dis\n",
     "        return df"
    ]
@@ -307,81 +326,99 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Node, `self.delayed_process = True` flag is added for the same reason.\n",
-    "\n",
-    "### Compute the Nodes with customized GPU kernels\n",
+    "The `self.delayed_process = True` flag is added for the same reason as with `DistanceNumbaNode` i.e. to support `dask_cudf` data frames."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Computing using the Nodes with customized GPU kernels\n",
     "\n",
-    "First we construct the computation graph for gQuant"
+    "First we construct the computation graph for gquant."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "numba_distance_node = {\"id\": \"distance_by_numba\",\n",
-    "                       \"type\": NumbaDistanceNode,\n",
-    "                       \"conf\": {},\n",
-    "                       \"inputs\": [\"points\"]}\n",
-    "cupy_distance_node = {\"id\": \"distance_by_cupy\",\n",
-    "                      \"type\": CupyDistanceNode,\n",
-    "                      \"conf\": {},\n",
-    "                      \"inputs\": [\"points\"]}\n",
+    "numba_distance_node = {\n",
+    "    'id': 'distance_by_numba',\n",
+    "    'type': NumbaDistanceNode,\n",
+    "    'conf': {},\n",
+    "    'inputs': ['points']\n",
+    "}\n",
+    "\n",
+    "cupy_distance_node = {\n",
+    "    'id': 'distance_by_cupy',\n",
+    "    'type': CupyDistanceNode,\n",
+    "    'conf': {},\n",
+    "    'inputs': ['points']\n",
+    "}\n",
     "\n",
-    "graph = [input_node, numba_distance_node, cupy_distance_node, distance_node]\n",
-    "G = viz_graph(graph)\n",
-    "draw(G, show='ipynb')"
+    "task_list = [input_node, numba_distance_node,\n",
+    "             cupy_distance_node, cudf_distance_node]\n",
+    "out_list = ['distance_by_numba', 'distance_by_cupy', 'distance_by_cudf']\n",
+    "task_graph = viz_graph(task_list)\n",
+    "draw(task_graph, show='ipynb')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then we run the tasks."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
-    "numba_df, cupy_df, gt_df = run(graph,\n",
-    "                               outputs=['distance_by_numba', 'distance_by_cupy',\n",
-    "                                        'distance_by_dataframe'],\n",
-    "                               replace={})"
+    "df_w_numba, df_w_cupy, df_w_cudf = run(task_list, out_list)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Use `verify` method defined above to verify the results:"
+    "Use `verify` function defined above to verify the results:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2.220446049250313e-16\n",
-      "2.220446049250313e-16\n"
+      "Max Difference: 2.220446049250313e-16\n",
+      "Max Difference: 2.220446049250313e-16\n"
      ]
     }
    ],
    "source": [
-    "print(verify(numba_df['distance_numba'], gt_df['distance']))\n",
-    "print(verify(cupy_df['distance_cupy'], gt_df['distance']))"
+    "mdiff = verify(df_w_cudf['distance_cudf'], df_w_numba['distance_numba'])\n",
+    "print('Max Difference: {}'.format(mdiff))\n",
+    "mdiff = verify(df_w_cudf['distance_cudf'], df_w_cupy['distance_cupy'])\n",
+    "print('Max Difference: {}'.format(mdiff))"
    ]
   },
   {
@@ -390,27 +427,16 @@
    "source": [
     "### Dask distributed computation\n",
     "\n",
-    "To evaluate the Nodes with customized GPU kernels in the GPU in Dask environment is straightfowrd as we already added `self.delayed_process = True` flag.\n",
+    "Using Dask and `dask-cudf` we can run the Nodes with customized GPU kernels on distributed dataframes. Under the hood of the `Node` class the Dask delayed processing API is handled for cudf dataframes when the `self.delayed_process = True` flag is set.\n",
     "\n",
-    "We first start the Dask environment"
+    "We first start a distributed Dask environment. When a dask client is instantiated it registers itself as the default Dask scheduler (<http://distributed.dask.org/en/latest/client.html>). Therefore all subsequent Dask distibuted dataframe operations will run in distributed fashion."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/conda/envs/rapids/lib/python3.6/site-packages/distributed/bokeh/core.py:74: UserWarning: \n",
-      "Port 8787 is already in use. \n",
-      "Perhaps you already have a cluster running?\n",
-      "Hosting the diagnostics dashboard on a random port instead.\n",
-      "  warnings.warn(\"\\n\" + msg)\n"
-     ]
-    },
     {
      "data": {
       "text/html": [
@@ -419,26 +445,26 @@
        "<td style=\"vertical-align: top; border: 0px solid white\">\n",
        "<h3>Client</h3>\n",
        "<ul>\n",
-       "  <li><b>Scheduler: </b>tcp://127.0.0.1:40522\n",
-       "  <li><b>Dashboard: </b><a href='http://127.0.0.1:43946/status' target='_blank'>http://127.0.0.1:43946/status</a>\n",
+       "  <li><b>Scheduler: </b>tcp://127.0.0.1:36065\n",
+       "  <li><b>Dashboard: </b><a href='http://127.0.0.1:8787/status' target='_blank'>http://127.0.0.1:8787/status</a>\n",
        "</ul>\n",
        "</td>\n",
        "<td style=\"vertical-align: top; border: 0px solid white\">\n",
        "<h3>Cluster</h3>\n",
        "<ul>\n",
-       "  <li><b>Workers: </b>8</li>\n",
-       "  <li><b>Cores: </b>8</li>\n",
-       "  <li><b>Memory: </b>536.39 GB</li>\n",
+       "  <li><b>Workers: </b>2</li>\n",
+       "  <li><b>Cores: </b>2</li>\n",
+       "  <li><b>Memory: </b>135.17 GB</li>\n",
        "</ul>\n",
        "</td>\n",
        "</tr>\n",
        "</table>"
       ],
       "text/plain": [
-       "<Client: scheduler='tcp://127.0.0.1:40522' processes=8 cores=8>"
+       "<Client: scheduler='tcp://127.0.0.1:36065' processes=2 cores=2>"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -455,12 +481,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The Dask status page can be popped up in the brwoser by following javascript commands:"
+    "The Dask status page can be displayed in a web browser at `<ip-address>:8787`. The ip-address corresponds to the machine where the dask cluster (scheduler) was launched. Most likely same ip-address as where this jupyter notebook is running. The javascript cell below will launch the dask status page otherwise manually go to the status page <http://distributed.dask.org/en/latest/web.html>. Using the Dask status page is convenient for monitoring dask distributed processing."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
@@ -481,7 +507,7 @@
        "<IPython.core.display.HTML object>"
       ]
      },
-     "execution_count": 16,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -506,83 +532,105 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We need a Node that partition the `cudf` dataframe into `dask_cudf` dataframe. Here we make 8 partitions:"
+    "The next step is to partition the `cudf` dataframe into a `dask_cudf` dataframe. Here we make the number of partitions correspond to the number of workers:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
     "class DistributedNode(Node):\n",
     "\n",
     "    def columns_setup(self,):\n",
-    "        self.required = {\"x\": \"float64\",\n",
-    "                         \"y\": \"float64\"}\n",
+    "        self.required = {'x': 'float64',\n",
+    "                         'y': 'float64'}\n",
     "\n",
     "    def process(self, inputs):\n",
-    "        df = inputs[0]\n",
-    "        return dask_cudf.from_cudf(df, npartitions=8)"
+    "        npartitions = self.conf['npartitions']\n",
+    "        df = inputs[0]        \n",
+    "        return dask_cudf.from_cudf(df, npartitions=npartitions)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The computation graph need to be changed to include this node"
+    "We add this distribution node to the computation graph to convert `cudf` dataframes into `dask-cudf` dataframes."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "input_node = {\"id\": \"points\",\n",
-    "              \"type\": PointNode,\n",
-    "              \"conf\": {},\n",
-    "              \"inputs\": []}\n",
-    "distributed_node = {\"id\": \"distributed_points\",\n",
-    "                    \"type\": DistributedNode,\n",
-    "                    \"conf\": {},\n",
-    "                    \"inputs\": [\"points\"]}\n",
-    "distance_node = {\"id\": \"distance_by_dataframe\",\n",
-    "                 \"type\": DistanceNode,\n",
-    "                 \"conf\": {},\n",
-    "                 \"inputs\": [\"points\"]}\n",
-    "numba_distance_node = {\"id\": \"distance_by_numba\",\n",
-    "                       \"type\": NumbaDistanceNode,\n",
-    "                       \"conf\": {},\n",
-    "                       \"inputs\": [\"distributed_points\"]}\n",
-    "cupy_distance_node = {\"id\": \"distance_by_cupy\",\n",
-    "                      \"type\": CupyDistanceNode,\n",
-    "                      \"conf\": {},\n",
-    "                      \"inputs\": [\"distributed_points\"]}\n",
-    "graph = [input_node, distributed_node, distance_node, numba_distance_node, cupy_distance_node]\n",
-    "G = viz_graph(graph)\n",
-    "draw(G, show='ipynb')"
+    "npartitions = len(client.scheduler_info()['workers'])\n",
+    "\n",
+    "input_node = {\n",
+    "    'id': 'points',\n",
+    "    'type': PointNode,\n",
+    "    'conf': {},\n",
+    "    'inputs': []\n",
+    "}\n",
+    "\n",
+    "distributed_node = {\n",
+    "    'id': 'distributed_points',\n",
+    "    'type': DistributedNode,\n",
+    "    'conf': {'npartitions': npartitions},\n",
+    "    'inputs': [\"points\"]\n",
+    "}\n",
+    "\n",
+    "cudf_distance_node = {\n",
+    "    'id': 'distance_by_cudf',\n",
+    "    'type': DistanceNode,\n",
+    "    'conf': {},\n",
+    "    'inputs': ['points']\n",
+    "}\n",
+    "\n",
+    "numba_distance_node = {\n",
+    "    'id': 'distance_by_numba',\n",
+    "    'type': NumbaDistanceNode,\n",
+    "    'conf': {},\n",
+    "    'inputs': ['distributed_points']\n",
+    "}\n",
+    "\n",
+    "cupy_distance_node = {\n",
+    "    'id': 'distance_by_cupy',\n",
+    "    'type': CupyDistanceNode,\n",
+    "    'conf': {},\n",
+    "    'inputs': ['distributed_points']\n",
+    "}\n",
+    "\n",
+    "task_list = [input_node, distributed_node, cudf_distance_node,\n",
+    "             numba_distance_node, cupy_distance_node]\n",
+    "out_list = ['distance_by_numba', 'distance_by_cupy', 'distance_by_cudf']\n",
+    "task_graph = viz_graph(task_list)\n",
+    "draw(task_graph, show='ipynb')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
-    "numba_df, cupy_df, gt_df = run(graph, ['distance_by_numba', 'distance_by_cupy', 'distance_by_dataframe'], {})"
+    "df_w_numba, df_w_cupy, df_w_cudf = run(task_list, out_list)\n",
+    "df_w_numba = df_w_numba.compute()\n",
+    "df_w_cupy = df_w_cupy.compute()"
    ]
   },
   {
@@ -592,6 +640,43 @@
     "Verify the results:"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Max Difference: 2.220446049250313e-16\n",
+      "Max Difference: 2.220446049250313e-16\n"
+     ]
+    }
+   ],
+   "source": [
+    "mdiff = verify(df_w_cudf['distance_cudf'], df_w_numba['distance_numba'])\n",
+    "print('Max Difference: {}'.format(mdiff))\n",
+    "mdiff = verify(df_w_cudf['distance_cudf'], df_w_cupy['distance_cupy'])\n",
+    "print('Max Difference: {}'.format(mdiff))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One limitation to be aware of when using customized kernels within Nodes in the Dask environment, is that each GPU kernel works on one partition of the dataframe. Therefore if the computation depends on other partitions of the dataframe the approach above does not work."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Saving Custom Nodes and Kernels\n",
+    "\n",
+    "The gquant framework already implements a number of Nodes. These can be found in `gquant.plugin_nodes` submodules. Refer to those nodes for reference implementations. For example:"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 20,
@@ -601,55 +686,337 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2.220446049250313e-16\n",
-      "2.220446049250313e-16\n"
+      "class CsvStockLoader(Node):\n",
+      "\n",
+      "    def columns_setup(self):\n",
+      "        self.required = {}\n",
+      "        self.addition = {\"datetime\": \"datetime64[ms]\",\n",
+      "                         \"asset\": \"int64\",\n",
+      "                         \"volume\": \"float64\",\n",
+      "                         \"close\": \"float64\",\n",
+      "                         \"open\": \"float64\",\n",
+      "                         \"high\": \"float64\",\n",
+      "                         \"low\": \"float64\"}\n",
+      "        self.deletion = None\n",
+      "        self.retention = None\n",
+      "\n",
+      "    def process(self, inputs):\n",
+      "        \"\"\"\n",
+      "        Load the end of day stock CSV data into cuDF dataframe\n",
+      "\n",
+      "        Arguments\n",
+      "        -------\n",
+      "         inputs: list\n",
+      "             empty list\n",
+      "        Returns\n",
+      "        -------\n",
+      "        cudf.DataFrame\n",
+      "        \"\"\"\n",
+      "\n",
+      "        df = pd.read_csv(self.conf['path'],\n",
+      "                         converters={'DTE': lambda x: pd.Timestamp(str(x))})\n",
+      "        df = df[['DTE', 'OPEN',\n",
+      "                 'CLOSE', 'HIGH',\n",
+      "                 'LOW', 'SM_ID', 'VOLUME']]\n",
+      "        df['VOLUME'] /= 1000\n",
+      "        output = cudf.from_pandas(df)\n",
+      "        # change the names\n",
+      "        output.columns = ['datetime', 'open', 'close', 'high',\n",
+      "                          'low', \"asset\", 'volume']\n",
+      "        return output\n",
+      "\n"
      ]
     }
    ],
    "source": [
-    "print(verify(numba_df['distance_numba'].compute(), gt_df['distance']))\n",
-    "print(verify(cupy_df['distance_cupy'].compute(), gt_df['distance']))"
+    "import inspect\n",
+    "from gquant.plugin_nodes.dataloader import CsvStockLoader\n",
+    "\n",
+    "print(inspect.getsource(CsvStockLoader))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "There is one limitation for using customized kernels in the Nodes in the Dask environment. Each GPU kernel is assumed to work on one partition of the dataframe. So if the computation depends on other partitions of the dataframe, this approach doesn't work.\n",
+    "The customized kernels and nodes can be saved to your own python modules for future re-use instead of having to re-define them at runtime. We will take the nodes we defined above and write them to a python module. Then we will re-run our workflow importing the Nodes from the custom module we wrote out."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overwriting custom_nodes.py\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%writefile custom_nodes.py\n",
+    "\n",
+    "import math\n",
+    "import numpy as np\n",
+    "from numba import cuda\n",
+    "import cupy\n",
+    "import cudf\n",
+    "import dask_cudf\n",
+    "\n",
+    "from gquant.dataframe_flow import Node\n",
+    "# from librmm_cffi import librmm as rmm\n",
+    "\n",
+    "\n",
+    "class PointNode(Node):\n",
+    "\n",
+    "    def columns_setup(self,):\n",
+    "        self.required = {}\n",
+    "        self.addition = {'x': 'float64',\n",
+    "                         'y': 'float64'}\n",
+    "\n",
+    "    def process(self, inputs):\n",
+    "        df = cudf.DataFrame()\n",
+    "        df['x'] = np.random.rand(1000)\n",
+    "        df['y'] = np.random.rand(1000)\n",
+    "        return df\n",
+    "\n",
+    "\n",
+    "class DistanceNode(Node):\n",
+    "\n",
+    "    def columns_setup(self,):\n",
+    "        self.required = {'x': 'float64',\n",
+    "                         'y': 'float64'}\n",
+    "        self.addition = {'distance_cudf': 'float64'}\n",
+    "\n",
+    "    def process(self, inputs):\n",
+    "        df = inputs[0]\n",
+    "        df['distance_cudf'] = (df['x']**2 + df['y']**2).sqrt()\n",
+    "        return df\n",
+    "\n",
+    "\n",
+    "@cuda.jit\n",
+    "def distance_kernel(x, y, distance, array_len):\n",
+    "    # ii - overall thread index\n",
+    "    ii = cuda.threadIdx.x + cuda.blockIdx.x * cuda.blockDim.x\n",
+    "    if ii < array_len:\n",
+    "        distance[ii] = math.sqrt(x[ii]**2 + y[ii]**2)\n",
+    "\n",
+    "\n",
+    "class NumbaDistanceNode(Node):\n",
+    "\n",
+    "    def columns_setup(self,):\n",
+    "        self.required = {'x': 'float64',\n",
+    "                         'y': 'float64'}\n",
+    "        self.addition = {'distance_numba': 'float64'}\n",
+    "        self.delayed_process = True\n",
+    "\n",
+    "    def process(self, inputs):\n",
+    "        df = inputs[0]\n",
+    "        number_of_threads = 16\n",
+    "        number_of_blocks = ((len(df) - 1)//number_of_threads) + 1\n",
+    "        # Inits device array by setting 0 for each index.\n",
+    "        # df['distance_numba'] = 0.0\n",
+    "        darr = cuda.device_array(len(df))\n",
+    "        distance_kernel[(number_of_blocks,), (number_of_threads,)](\n",
+    "            df['x'].to_gpu_array(),\n",
+    "            df['y'].to_gpu_array(),\n",
+    "            darr,\n",
+    "            len(df))\n",
+    "        df['distance_numba'] = darr\n",
+    "        return df\n",
+    "\n",
+    "\n",
+    "raw_kernel = cupy.RawKernel(r'''\n",
+    "    extern \"C\" __global__\n",
+    "    void compute_distance(const double* x, const double* y,\n",
+    "            double* distance, int arr_len) {\n",
+    "        int tid = blockDim.x * blockIdx.x + threadIdx.x;\n",
+    "        if (tid < arr_len){\n",
+    "        distance[tid] = sqrt(x[tid]*x[tid] + y[tid]*y[tid]);\n",
+    "        }\n",
+    "    }\n",
+    "''', 'compute_distance')\n",
+    "\n",
+    "\n",
+    "class CupyDistanceNode(Node):\n",
+    "\n",
+    "    def columns_setup(self,):\n",
+    "        self.required = {'x': 'float64',\n",
+    "                         'y': 'float64'}\n",
+    "        self.addition = {'distance_cupy': 'float64'}\n",
+    "        self.delayed_process = True\n",
+    "\n",
+    "    def process(self, inputs):\n",
+    "        df = inputs[0]\n",
+    "        # cupy_x = cupy.asarray(df['x'].to_gpu_array())\n",
+    "        # cupy_y = cupy.asarray(df['y'].to_gpu_array())\n",
+    "        cupy_x = cupy.asarray(df['x'])\n",
+    "        cupy_y = cupy.asarray(df['y'])\n",
+    "        number_of_threads = 16\n",
+    "        number_of_blocks = ((len(df) - 1)//number_of_threads) + 1\n",
+    "        dis = cupy.ndarray(len(df), dtype=cupy.float64)\n",
+    "        raw_kernel((number_of_blocks,), (number_of_threads,),\n",
+    "                   (cupy_x, cupy_y, dis, len(df)))\n",
+    "        df['distance_cupy'] = dis\n",
+    "        return df\n",
     "\n",
-    "### Conclusions\n",
     "\n",
-    "Using customized GPU kernels allows data scientists to implement lots of complicated logics. We show it can be done either by Numba method or CuPy method.\n",
+    "class DistributedNode(Node):\n",
+    "\n",
+    "    def columns_setup(self,):\n",
+    "        self.required = {'x': 'float64',\n",
+    "                         'y': 'float64'}\n",
+    "\n",
+    "    def process(self, inputs):\n",
+    "        npartitions = self.conf['npartitions']\n",
+    "        df = inputs[0]\n",
+    "        return dask_cudf.from_cudf(df, npartitions=npartitions)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When defining the tasks we specify `filepath` for the path to the python module that has the Node definition. Notice, that the `type` is specified as a string instead of class. The string is the class name of the node that will be imported for running a task."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "npartitions = len(client.scheduler_info()['workers'])\n",
+    "\n",
+    "input_node = {\n",
+    "    'id': 'points',\n",
+    "    'type': 'PointNode',\n",
+    "    'conf': {},\n",
+    "    'inputs': [],\n",
+    "    'filepath': 'custom_nodes.py'\n",
+    "}\n",
     "\n",
-    "The Numba method allows data scientists to use their familar Python langague to write GPU kernels. It is easy to write and relatively fast in performance. However there is some overheads of compiling the kernels whenever this GPU kernel is used for the first time in the Python process. Currently Numba library only supports primitive data types. Some advance CUDA programming features like function pointer and function recursions are not supported. \n",
+    "distributed_node = {\n",
+    "    'id': 'distributed_points',\n",
+    "    'type': 'DistributedNode',\n",
+    "    'conf': {'npartitions': npartitions},\n",
+    "    'inputs': ['points'],\n",
+    "    'filepath': 'custom_nodes.py'\n",
+    "}\n",
     "\n",
-    "The Cupy method is very flexible because data scientists is writing C++/C GPU kernels. All the CUDA programming features are supported. It compiles the kernel and caches to the filesystem. The launch overhead is low. As GPU kernel is built statically, the runtime efficiency is highest. However it is hard for data scientists to use becasue C/C++ programming skills are needed. \n",
+    "cudf_distance_node = {\n",
+    "    'id': 'distance_by_cudf',\n",
+    "    'type': 'DistanceNode',\n",
+    "    'conf': {},\n",
+    "    'inputs': ['points'],\n",
+    "    'filepath': 'custom_nodes.py'\n",
+    "}\n",
     "\n",
-    "There is a comparison table\n",
+    "numba_distance_node = {\n",
+    "    'id': 'distance_by_numba',\n",
+    "    'type': 'NumbaDistanceNode',\n",
+    "    'conf': {},\n",
+    "    'inputs': ['distributed_points'],\n",
+    "    'filepath': 'custom_nodes.py'\n",
+    "}\n",
+    "\n",
+    "cupy_distance_node = {\n",
+    "    'id': 'distance_by_cupy',\n",
+    "    'type': 'CupyDistanceNode',\n",
+    "    'conf': {},\n",
+    "    'inputs': ['distributed_points'],\n",
+    "    'filepath': 'custom_nodes.py'\n",
+    "}\n",
+    "\n",
+    "task_list = [input_node, distributed_node, cudf_distance_node,\n",
+    "             numba_distance_node, cupy_distance_node]\n",
+    "out_list = ['distance_by_numba', 'distance_by_cupy', 'distance_by_cudf']\n",
+    "task_graph = viz_graph(task_list)\n",
+    "draw(task_graph, show='ipynb')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Max Difference: 2.220446049250313e-16\n",
+      "Max Difference: 2.220446049250313e-16\n"
+     ]
+    }
+   ],
+   "source": [
+    "df_w_numba, df_w_cupy, df_w_cudf = run(task_list, out_list)\n",
+    "df_w_numba = df_w_numba.compute()\n",
+    "df_w_cupy = df_w_cupy.compute()\n",
+    "\n",
+    "mdiff = verify(df_w_cudf['distance_cudf'], df_w_numba['distance_numba'])\n",
+    "print('Max Difference: {}'.format(mdiff))\n",
+    "mdiff = verify(df_w_cudf['distance_cudf'], df_w_cupy['distance_cupy'])\n",
+    "print('Max Difference: {}'.format(mdiff))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Conclusion\n",
+    "\n",
+    "Using customized GPU kernels allows data scientists to implement and incorporate advanced algorithms. We demonstrated implementations using Numba and CuPy.\n",
+    "\n",
+    "The Numba approach enables data scientists to write GPU kernels directly in the Python language. Numba is easy to use for implementing and accelerating computations. However there is some overhead incurred for compiling the kernels whenever the Numba GPU kernels are used for the first time in a Python process. Currently Numba library only supports primitive data types. Some advanced CUDA programming features, such as function pointers and function recursions are not supported. \n",
+    "\n",
+    "The Cupy method is very flexible, because data scientists are writing C/C++ GPU kernels with CUDA directly. All the CUDA programming features are supported. CuPy compiles the kernel and caches the device code to the filesystem. The launch overhead is low. Also, the GPU kernel is built statically resulting in runtime efficiency. However it might be harder for data scientists to use, because C/C++ programming is more complicated. \n",
+    "\n",
+    "Below is a brief summary comparison table:\n",
     "\n",
     "| Methods | Development Difficulty | Flexibility | Efficiency | Lattency |\n",
     "|---|---|---|---|---|\n",
     "| Numba method | medium | medium | low | high |\n",
     "| CuPy method | hard | high  | high | low |\n",
     "\n",
-    "We recommend data scientists to choose the right approach to balance the efficiency, lattency, difficulty and flexibility for their workflow. \n",
+    "We recommend that the data scientists select the approach appropriate for their task taking into consideration the efficiency, latency, difficulty and flexibility of their workflow. \n",
     "\n",
-    "In this blog, we also show wrapping the customize GPU kernels in gQuant nodes, it is easy to include them into the Dask distributed computation graph. Because the gQuant handles the low-level Daks interface for the developer."
+    "In this blog, we showed how to wrap the customized GPU kernels in gquant nodes. Also, by taking advantage of having the gquant handle the low-level Dask interfaces for the developer, we demonstrated how to use the gquant workflow with Dask distributed computations."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "# Clean up\n",
+    "\n",
+    "# Shutdown the Dask cluster\n",
+    "client.close()\n",
+    "cluster.close()"
+   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "py36-rapids",
    "language": "python",
-   "name": "python3"
+   "name": "py36-rapids"
   },
   "language_info": {
    "codemirror_mode": {
diff --git a/notebook/cuIndicator/indicator_demo.ipynb b/notebook/cuIndicator/indicator_demo.ipynb
index 953e00cd..ffa8d477 100644
--- a/notebook/cuIndicator/indicator_demo.ipynb
+++ b/notebook/cuIndicator/indicator_demo.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -27,7 +27,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -60,7 +60,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -104,7 +104,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "80e2d161f7ee4b70bd605a8278e36745",
+       "model_id": "53c64e5d71db4650ba3ecc55e9990098",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1283,24 +1283,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
     "scrolled": false
    },
-   "outputs": [
-    {
-     "ename": "KeyError",
-     "evalue": "'High'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-5-e34775186425>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mci\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mppsr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'High'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Low'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Close'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mR1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m#print (output[100:].fillna(0))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~conda/envs/rapids/lib/python3.6/site-packages/cudf-0.7.1-py3.6-linux-x86_64.egg/cudf/dataframe/dataframe.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, arg)\u001b[0m\n\u001b[1;32m    221\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_column_major\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    222\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnumbers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNumber\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 223\u001b[0;31m             \u001b[0ms\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cols\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    224\u001b[0m             \u001b[0ms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    225\u001b[0m             \u001b[0ms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mKeyError\u001b[0m: 'High'"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "output = ci.ppsr(df['High'],df['Low'],df['Close'])\n",
     "print (output)\n",
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/unit/technical_indicators.py b/tests/unit/technical_indicators.py
new file mode 100644
index 00000000..489e6105
--- /dev/null
+++ b/tests/unit/technical_indicators.py
@@ -0,0 +1,571 @@
+# flake8: noqa
+"""
+Indicators as shown by Peter Bakker at:
+https://www.quantopian.com/posts/technical-analysis-indicators-without-talib-code
+"""
+
+"""
+25-Mar-2018: Fixed syntax to support the newest version of Pandas. Warnings should no longer appear.
+             Fixed some bugs regarding min_periods and NaN.
+
+			 If you find any bugs, please report to github.com/palmbook
+"""
+
+# Import Built-Ins
+import logging
+
+# Import Third-Party
+import pandas as pd
+import numpy as np
+
+# Import Homebrew
+
+# Init Logging Facilities
+log = logging.getLogger(__name__)
+
+
+def moving_average(df, n):
+    """Calculate the moving average for the given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    MA = pd.Series(df['Close'].rolling(n, min_periods=n).mean(), name='MA_' + str(n))
+    df = df.join(MA)
+    return df
+
+
+def exponential_moving_average(df, n):
+    """
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    EMA = pd.Series(df['Close'].ewm(span=n, min_periods=n).mean(), name='EMA_' + str(n))
+    df = df.join(EMA)
+    return df
+
+
+def momentum(df, n):
+    """
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    M = pd.Series(df['Close'].diff(n), name='Momentum_' + str(n))
+    df = df.join(M)
+    return df
+
+
+def rate_of_change(df, n):
+    """
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    M = df['Close'].diff(n - 1)
+    N = df['Close'].shift(n - 1)
+    ROC = pd.Series(M / N, name='ROC_' + str(n))
+    df = df.join(ROC)
+    return df
+
+
+def average_true_range(df, n):
+    """
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    i = 0
+    TR_l = [0]
+    while i < df.index[-1]:
+        TR = max(df.loc[i + 1, 'High'], df.loc[i, 'Close']) - min(df.loc[i + 1, 'Low'], df.loc[i, 'Close'])
+        TR_l.append(TR)
+        i = i + 1
+    TR_s = pd.Series(TR_l)
+    ATR = pd.Series(TR_s.ewm(span=n, min_periods=n).mean(), name='ATR_' + str(n))
+    df = df.join(ATR)
+    return df
+
+
+def bollinger_bands(df, n):
+    """
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    MA = pd.Series(df['Close'].rolling(n, min_periods=n).mean())
+    MSD = pd.Series(df['Close'].rolling(n, min_periods=n).std())
+    b1 = 4 * MSD / MA
+    B1 = pd.Series(b1, name='BollingerB_' + str(n))
+    df = df.join(B1)
+    b2 = (df['Close'] - MA + 2 * MSD) / (4 * MSD)
+    B2 = pd.Series(b2, name='Bollinger%b_' + str(n))
+    df = df.join(B2)
+    return df
+
+
+def ppsr(df):
+    """Calculate Pivot Points, Supports and Resistances for given data
+
+    :param df: pandas.DataFrame
+    :return: pandas.DataFrame
+    """
+    PP = pd.Series((df['High'] + df['Low'] + df['Close']) / 3)
+    R1 = pd.Series(2 * PP - df['Low'])
+    S1 = pd.Series(2 * PP - df['High'])
+    R2 = pd.Series(PP + df['High'] - df['Low'])
+    S2 = pd.Series(PP - df['High'] + df['Low'])
+    R3 = pd.Series(df['High'] + 2 * (PP - df['Low']))
+    S3 = pd.Series(df['Low'] - 2 * (df['High'] - PP))
+    psr = {'PP': PP, 'R1': R1, 'S1': S1, 'R2': R2, 'S2': S2, 'R3': R3, 'S3': S3}
+    PSR = pd.DataFrame(psr)
+    df = df.join(PSR)
+    return df
+
+
+def stochastic_oscillator_k(df):
+    """Calculate stochastic oscillator %K for given data.
+
+    :param df: pandas.DataFrame
+    :return: pandas.DataFrame
+    """
+    SOk = pd.Series((df['Close'] - df['Low']) / (df['High'] - df['Low']), name='SO%k')
+    df = df.join(SOk)
+    return df
+
+
+def stochastic_oscillator_d(df, n):
+    """Calculate stochastic oscillator %D for given data.
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    SOk = pd.Series((df['Close'] - df['Low']) / (df['High'] - df['Low']), name='SO%k')
+    SOd = pd.Series(SOk.ewm(span=n, min_periods=n).mean(), name='SO%d_' + str(n))
+    df = df.join(SOd)
+    return df
+
+
+def trix(df, n):
+    """Calculate TRIX for given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    EX1 = df['Close'].ewm(span=n, min_periods=n).mean()
+    EX2 = EX1.ewm(span=n, min_periods=n).mean()
+    EX3 = EX2.ewm(span=n, min_periods=n).mean()
+    i = 0
+    ROC_l = [np.nan]
+    while i + 1 <= df.index[-1]:
+        ROC = (EX3[i + 1] - EX3[i]) / EX3[i]
+        ROC_l.append(ROC)
+        i = i + 1
+    Trix = pd.Series(ROC_l, name='Trix_' + str(n))
+    df = df.join(Trix)
+    return df
+
+
+def average_directional_movement_index(df, n, n_ADX):
+    """Calculate the Average Directional Movement Index for given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :param n_ADX:
+    :return: pandas.DataFrame
+    """
+    i = 0
+    UpI = []
+    DoI = []
+    while i + 1 <= df.index[-1]:
+        UpMove = df.loc[i + 1, 'High'] - df.loc[i, 'High']
+        DoMove = df.loc[i, 'Low'] - df.loc[i + 1, 'Low']
+        if UpMove > DoMove and UpMove > 0:
+            UpD = UpMove
+        else:
+            UpD = 0
+        UpI.append(UpD)
+        if DoMove > UpMove and DoMove > 0:
+            DoD = DoMove
+        else:
+            DoD = 0
+        DoI.append(DoD)
+        i = i + 1
+    i = 0
+    TR_l = [0]
+    while i < df.index[-1]:
+        TR = max(df.loc[i + 1, 'High'], df.loc[i, 'Close']) - min(df.loc[i + 1, 'Low'], df.loc[i, 'Close'])
+        TR_l.append(TR)
+        i = i + 1
+    TR_s = pd.Series(TR_l)
+    ATR = pd.Series(TR_s.ewm(span=n, min_periods=n).mean())
+    UpI = pd.Series(UpI)
+    DoI = pd.Series(DoI)
+    PosDI = pd.Series(UpI.ewm(span=n, min_periods=n).mean() / ATR)
+    NegDI = pd.Series(DoI.ewm(span=n, min_periods=n).mean() / ATR)
+    ADX = pd.Series((abs(PosDI - NegDI) / (PosDI + NegDI)).ewm(span=n_ADX, min_periods=n_ADX).mean(),
+                    name='ADX_' + str(n) + '_' + str(n_ADX))
+    df = df.join(ADX)
+    return df
+
+
+def macd(df, n_fast, n_slow):
+    """Calculate MACD, MACD Signal and MACD difference
+
+    :param df: pandas.DataFrame
+    :param n_fast:
+    :param n_slow:
+    :return: pandas.DataFrame
+    """
+    EMAfast = pd.Series(df['Close'].ewm(span=n_fast, min_periods=n_slow).mean())
+    EMAslow = pd.Series(df['Close'].ewm(span=n_slow, min_periods=n_slow).mean())
+    MACD = pd.Series(EMAfast - EMAslow, name='MACD_' + str(n_fast) + '_' + str(n_slow))
+    MACDsign = pd.Series(MACD.ewm(span=9, min_periods=9).mean(), name='MACDsign_' + str(n_fast) + '_' + str(n_slow))
+    MACDdiff = pd.Series(MACD - MACDsign, name='MACDdiff_' + str(n_fast) + '_' + str(n_slow))
+    df = df.join(MACD)
+    df = df.join(MACDsign)
+    df = df.join(MACDdiff)
+    return df
+
+
+def mass_index(df):
+    """Calculate the Mass Index for given data.
+
+    :param df: pandas.DataFrame
+    :return: pandas.DataFrame
+    """
+    Range = df['High'] - df['Low']
+    EX1 = Range.ewm(span=9, min_periods=9).mean()
+    EX2 = EX1.ewm(span=9, min_periods=9).mean()
+    Mass = EX1 / EX2
+    MassI = pd.Series(Mass.rolling(25).sum(), name='Mass Index')
+    df = df.join(MassI)
+    return df
+
+
+def vortex_indicator(df, n):
+    """Calculate the Vortex Indicator for given data.
+
+    Vortex Indicator described here:
+        http://www.vortexindicator.com/VFX_VORTEX.PDF
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    i = 0
+    TR = [0]
+    while i < df.index[-1]:
+        Range = max(df.loc[i + 1, 'High'], df.loc[i, 'Close']) - min(df.loc[i + 1, 'Low'], df.loc[i, 'Close'])
+        TR.append(Range)
+        i = i + 1
+    i = 0
+    VM = [0]
+    while i < df.index[-1]:
+        Range = abs(df.loc[i + 1, 'High'] - df.loc[i, 'Low']) - abs(df.loc[i + 1, 'Low'] - df.loc[i, 'High'])
+        VM.append(Range)
+        i = i + 1
+    VI = pd.Series(pd.Series(VM).rolling(n).sum() / pd.Series(TR).rolling(n).sum(), name='Vortex_' + str(n))
+    df = df.join(VI)
+    return df
+
+
+def kst_oscillator(df, r1, r2, r3, r4, n1, n2, n3, n4):
+    """Calculate KST Oscillator for given data.
+
+    :param df: pandas.DataFrame
+    :param r1:
+    :param r2:
+    :param r3:
+    :param r4:
+    :param n1:
+    :param n2:
+    :param n3:
+    :param n4:
+    :return: pandas.DataFrame
+    """
+    M = df['Close'].diff(r1 - 1)
+    N = df['Close'].shift(r1 - 1)
+    ROC1 = M / N
+    M = df['Close'].diff(r2 - 1)
+    N = df['Close'].shift(r2 - 1)
+    ROC2 = M / N
+    M = df['Close'].diff(r3 - 1)
+    N = df['Close'].shift(r3 - 1)
+    ROC3 = M / N
+    M = df['Close'].diff(r4 - 1)
+    N = df['Close'].shift(r4 - 1)
+    ROC4 = M / N
+    KST = pd.Series(
+        ROC1.rolling(n1).sum() + ROC2.rolling(n2).sum() * 2 + ROC3.rolling(n3).sum() * 3 + ROC4.rolling(n4).sum() * 4,
+        name='KST_' + str(r1) + '_' + str(r2) + '_' + str(r3) + '_' + str(r4) + '_' + str(n1) + '_' + str(
+            n2) + '_' + str(n3) + '_' + str(n4))
+    df = df.join(KST)
+    return df
+
+
+def relative_strength_index(df, n):
+    """Calculate Relative Strength Index(RSI) for given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    i = 0
+    UpI = [0]
+    DoI = [0]
+    while i + 1 <= df.index[-1]:
+        UpMove = df.loc[i + 1, 'High'] - df.loc[i, 'High']
+        DoMove = df.loc[i, 'Low'] - df.loc[i + 1, 'Low']
+        if UpMove > DoMove and UpMove > 0:
+            UpD = UpMove
+        else:
+            UpD = 0
+        UpI.append(UpD)
+        if DoMove > UpMove and DoMove > 0:
+            DoD = DoMove
+        else:
+            DoD = 0
+        DoI.append(DoD)
+        i = i + 1
+    UpI = pd.Series(UpI)
+    DoI = pd.Series(DoI)
+    PosDI = pd.Series(UpI.ewm(span=n, min_periods=n).mean())
+    NegDI = pd.Series(DoI.ewm(span=n, min_periods=n).mean())
+    RSI = pd.Series(PosDI / (PosDI + NegDI), name='RSI_' + str(n))
+    df = df.join(RSI)
+    return df
+
+
+def true_strength_index(df, r, s):
+    """Calculate True Strength Index (TSI) for given data.
+
+    :param df: pandas.DataFrame
+    :param r:
+    :param s:
+    :return: pandas.DataFrame
+    """
+    M = pd.Series(df['Close'].diff(1))
+    aM = abs(M)
+    EMA1 = pd.Series(M.ewm(span=r, min_periods=r).mean())
+    aEMA1 = pd.Series(aM.ewm(span=r, min_periods=r).mean())
+    EMA2 = pd.Series(EMA1.ewm(span=s, min_periods=s).mean())
+    aEMA2 = pd.Series(aEMA1.ewm(span=s, min_periods=s).mean())
+    TSI = pd.Series(EMA2 / aEMA2, name='TSI_' + str(r) + '_' + str(s))
+    df = df.join(TSI)
+    return df
+
+
+def accumulation_distribution(df, n):
+    """Calculate Accumulation/Distribution for given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    ad = (2 * df['Close'] - df['High'] - df['Low']) / (df['High'] - df['Low']) * df['Volume']
+    M = ad.diff(n - 1)
+    N = ad.shift(n - 1)
+    ROC = M / N
+    AD = pd.Series(ROC, name='Acc/Dist_ROC_' + str(n))
+    df = df.join(AD)
+    return df
+
+
+def chaikin_oscillator(df):
+    """Calculate Chaikin Oscillator for given data.
+
+    :param df: pandas.DataFrame
+    :return: pandas.DataFrame
+    """
+    ad = (2 * df['Close'] - df['High'] - df['Low']) / (df['High'] - df['Low']) * df['Volume']
+    Chaikin = pd.Series(ad.ewm(span=3, min_periods=3).mean() - ad.ewm(span=10, min_periods=10).mean(), name='Chaikin')
+    df = df.join(Chaikin)
+    return df
+
+
+def money_flow_index(df, n):
+    """Calculate Money Flow Index and Ratio for given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    PP = (df['High'] + df['Low'] + df['Close']) / 3
+    i = 0
+    PosMF = [0]
+    while i < df.index[-1]:
+        if PP[i + 1] > PP[i]:
+            PosMF.append(PP[i + 1] * df.loc[i + 1, 'Volume'])
+        else:
+            PosMF.append(0)
+        i = i + 1
+    PosMF = pd.Series(PosMF)
+    TotMF = PP * df['Volume']
+    MFR = pd.Series(PosMF / TotMF)
+    MFI = pd.Series(MFR.rolling(n, min_periods=n).mean(), name='MFI_' + str(n))
+    df = df.join(MFI)
+    return df
+
+
+def on_balance_volume(df, n):
+    """Calculate On-Balance Volume for given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    i = 0
+    OBV = [0]
+    while i < df.index[-1]:
+        if df.loc[i + 1, 'Close'] - df.loc[i, 'Close'] > 0:
+            OBV.append(df.loc[i + 1, 'Volume'])
+        if df.loc[i + 1, 'Close'] - df.loc[i, 'Close'] == 0:
+            OBV.append(0)
+        if df.loc[i + 1, 'Close'] - df.loc[i, 'Close'] < 0:
+            OBV.append(-df.loc[i + 1, 'Volume'])
+        i = i + 1
+    OBV = pd.Series(OBV)
+    OBV_ma = pd.Series(OBV.rolling(n, min_periods=n).mean(), name='OBV_' + str(n))
+    df = df.join(OBV_ma)
+    return df
+
+
+def force_index(df, n):
+    """Calculate Force Index for given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    F = pd.Series(df['Close'].diff(n) * df['Volume'].diff(n), name='Force_' + str(n))
+    df = df.join(F)
+    return df
+
+
+def ease_of_movement(df, n):
+    """Calculate Ease of Movement for given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    EoM = (df['High'].diff(1) + df['Low'].diff(1)) * (df['High'] - df['Low']) / (2 * df['Volume'])
+    Eom_ma = pd.Series(EoM.rolling(n, min_periods=n).mean(), name='EoM_' + str(n))
+    df = df.join(Eom_ma)
+    return df
+
+
+def commodity_channel_index(df, n):
+    """Calculate Commodity Channel Index for given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    PP = (df['High'] + df['Low'] + df['Close']) / 3
+    CCI = pd.Series((PP - PP.rolling(n, min_periods=n).mean()) / PP.rolling(n, min_periods=n).std(),
+                    name='CCI_' + str(n))
+    df = df.join(CCI)
+    return df
+
+
+def coppock_curve(df, n):
+    """Calculate Coppock Curve for given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    M = df['Close'].diff(int(n * 11 / 10) - 1)
+    N = df['Close'].shift(int(n * 11 / 10) - 1)
+    ROC1 = M / N
+    M = df['Close'].diff(int(n * 14 / 10) - 1)
+    N = df['Close'].shift(int(n * 14 / 10) - 1)
+    ROC2 = M / N
+    Copp = pd.Series((ROC1 + ROC2).ewm(span=n, min_periods=n).mean(), name='Copp_' + str(n))
+    df = df.join(Copp)
+    return df
+
+
+def keltner_channel(df, n):
+    """Calculate Keltner Channel for given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    KelChM = pd.Series(((df['High'] + df['Low'] + df['Close']) / 3).rolling(n, min_periods=n).mean(),
+                       name='KelChM_' + str(n))
+    KelChU = pd.Series(((4 * df['High'] - 2 * df['Low'] + df['Close']) / 3).rolling(n, min_periods=n).mean(),
+                       name='KelChU_' + str(n))
+    KelChD = pd.Series(((-2 * df['High'] + 4 * df['Low'] + df['Close']) / 3).rolling(n, min_periods=n).mean(),
+                       name='KelChD_' + str(n))
+    df = df.join(KelChM)
+    df = df.join(KelChU)
+    df = df.join(KelChD)
+    return df
+
+
+def ultimate_oscillator(df):
+    """Calculate Ultimate Oscillator for given data.
+
+    :param df: pandas.DataFrame
+    :return: pandas.DataFrame
+    """
+    i = 0
+    TR_l = [0]
+    BP_l = [0]
+    while i < df.index[-1]:
+        TR = max(df.loc[i + 1, 'High'], df.loc[i, 'Close']) - min(df.loc[i + 1, 'Low'], df.loc[i, 'Close'])
+        TR_l.append(TR)
+        BP = df.loc[i + 1, 'Close'] - min(df.loc[i + 1, 'Low'], df.loc[i, 'Close'])
+        BP_l.append(BP)
+        i = i + 1
+    UltO = pd.Series((4 * pd.Series(BP_l).rolling(7).sum() / pd.Series(TR_l).rolling(7).sum()) + (
+                2 * pd.Series(BP_l).rolling(14).sum() / pd.Series(TR_l).rolling(14).sum()) + (
+                                 pd.Series(BP_l).rolling(28).sum() / pd.Series(TR_l).rolling(28).sum()),
+                     name='Ultimate_Osc')
+    df = df.join(UltO)
+    return df
+
+
+def donchian_channel(df, n):
+    """Calculate donchian channel of given pandas data frame.
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    i = 0
+    dc_l = []
+    while i < n - 1:
+        dc_l.append(0)
+        i += 1
+
+    i = 0
+    while i + n - 1 < df.index[-1]:
+        dc = max(df['High'].ix[i:i + n - 1]) - min(df['Low'].ix[i:i + n - 1])
+        dc_l.append(dc)
+        i += 1
+
+    donchian_chan = pd.Series(dc_l, name='Donchian_' + str(n))
+    donchian_chan = donchian_chan.shift(n - 1)
+    return df.join(donchian_chan)
+
+
+def standard_deviation(df, n):
+    """Calculate Standard Deviation for given data.
+
+    :param df: pandas.DataFrame
+    :param n:
+    :return: pandas.DataFrame
+    """
+    df = df.join(pd.Series(df['Close'].rolling(n, min_periods=n).std(), name='STD_' + str(n)))
+    return df
diff --git a/tests/unit/test_indicator.py b/tests/unit/test_indicator.py
new file mode 100644
index 00000000..eb33590a
--- /dev/null
+++ b/tests/unit/test_indicator.py
@@ -0,0 +1,377 @@
+'''
+Workflow Serialization Unit Tests
+
+To run unittests:
+
+# Using standard library unittest
+
+python -m unittest -v
+python -m unittest tests/unit/test_indicator.py -v
+
+or
+
+python -m unittest discover <test_directory>
+python -m unittest discover -s <directory> -p 'test_*.py'
+
+# Using pytest
+# "conda install pytest" or "pip install pytest"
+pytest -v tests
+pytest -v tests/unit/test_indicator.py
+
+'''
+import warnings
+import pandas as pd
+import unittest
+import pathlib
+import cudf
+import gquant.cuindicator as gi
+from . import technical_indicators as ti
+from .utils import make_orderer, error_function
+import numpy as np
+
+ordered, compare = make_orderer()
+unittest.defaultTestLoader.sortTestMethodsUsing = compare
+
+
+class TestIndicator(unittest.TestCase):
+
+    def setUp(self):
+        # ignore importlib warnings.
+        path = pathlib.Path(__file__)
+        self._pandas_data = pd.read_csv(str(path.parent)+'/testdata.csv.gz')
+        self._pandas_data['Volume'] /= 1000.0
+        self._cudf_data = cudf.from_pandas(self._pandas_data)
+        warnings.simplefilter('ignore', category=ImportWarning)
+        warnings.simplefilter('ignore', category=DeprecationWarning)
+
+    def tearDown(self):
+        pass
+
+    @ordered
+    def test_rate_of_return(self):
+        '''Test rate of return calculation'''
+        r_cudf = gi.rate_of_change(self._cudf_data['Close'], 2)
+        r_pandas = ti.rate_of_change(self._pandas_data, 2)
+        err = error_function(r_cudf, r_pandas.ROC_2)
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_trix(self):
+        """ test the trix calculation"""
+        r_cudf = gi.trix(self._cudf_data['Close'], 3)
+        r_pandas = ti.trix(self._pandas_data, 3)
+        err = error_function(r_cudf, r_pandas.Trix_3)
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_bollinger_bands(self):
+        """ test the bollinger_bands """
+        r_cudf = gi.bollinger_bands(self._cudf_data['Close'], 20)
+        r_pandas = ti.bollinger_bands(self._pandas_data, 20)
+        err = error_function(r_cudf.b1, r_pandas['BollingerB_20'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+        err = error_function(r_cudf.b2, r_pandas['Bollinger%b_20'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_macd(self):
+        """ test the macd """
+        n_fast = 10
+        n_slow = 20
+        r_cudf = gi.macd(self._cudf_data['Close'], n_fast, n_slow)
+        r_pandas = ti.macd(self._pandas_data, n_fast, n_slow)
+        err = error_function(r_cudf.MACD, r_pandas['MACD_10_20'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+        err = error_function(r_cudf.MACDdiff, r_pandas['MACDdiff_10_20'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+        err = error_function(r_cudf.MACDsign, r_pandas['MACDsign_10_20'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_average_true_range(self):
+        """ test the average true range """
+        r_cudf = gi.average_true_range(self._cudf_data['High'],
+                                       self._cudf_data['Low'],
+                                       self._cudf_data['Close'], 10)
+        r_pandas = ti.average_true_range(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['ATR_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_ppsr(self):
+        """ test the ppsr """
+        r_cudf = gi.ppsr(self._cudf_data['High'], self._cudf_data['Low'],
+                         self._cudf_data['Close'])
+        r_pandas = ti.ppsr(self._pandas_data)
+        err = error_function(r_cudf.PP, r_pandas['PP'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+        err = error_function(r_cudf.R1, r_pandas['R1'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+        err = error_function(r_cudf.S1, r_pandas['S1'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+        err = error_function(r_cudf.R2, r_pandas['R2'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+        err = error_function(r_cudf.S2, r_pandas['S2'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+        err = error_function(r_cudf.R3, r_pandas['R3'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+        err = error_function(r_cudf.S3, r_pandas['S3'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_stochastic_oscillator_k(self):
+        """ test the stochastic oscillator k """
+        r_cudf = gi.stochastic_oscillator_k(self._cudf_data['High'],
+                                            self._cudf_data['Low'],
+                                            self._cudf_data['Close'])
+        r_pandas = ti.stochastic_oscillator_k(self._pandas_data)
+        err = error_function(r_cudf, r_pandas['SO%k'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_stochastic_oscillator_d(self):
+        """ test the stochastic oscillator d """
+        r_cudf = gi.stochastic_oscillator_d(self._cudf_data['High'],
+                                            self._cudf_data['Low'],
+                                            self._cudf_data['Close'], 10)
+        r_pandas = ti.stochastic_oscillator_d(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['SO%d_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_average_directional_movement_index(self):
+        """ test the average_directional_movement_index """
+        r_cudf = gi.average_directional_movement_index(
+            self._cudf_data['High'],
+            self._cudf_data['Low'],
+            self._cudf_data['Close'],
+            10, 20)
+        r_pandas = ti.average_directional_movement_index(self._pandas_data,
+                                                         10, 20)
+        err = error_function(r_cudf, r_pandas['ADX_10_20'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_vortex_indicator(self):
+        """ test the vortex_indicator """
+        r_cudf = gi.vortex_indicator(self._cudf_data['High'],
+                                     self._cudf_data['Low'],
+                                     self._cudf_data['Close'], 10)
+        r_pandas = ti.vortex_indicator(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['Vortex_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_kst_oscillator(self):
+        """ test the kst_oscillator """
+        r_cudf = gi.kst_oscillator(self._cudf_data['Close'],
+                                   3, 4, 5, 6, 7, 8, 9, 10)
+        r_pandas = ti.kst_oscillator(self._pandas_data,
+                                     3, 4, 5, 6, 7, 8, 9, 10)
+        err = error_function(r_cudf, r_pandas['KST_3_4_5_6_7_8_9_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_relative_strength_index(self):
+        """ test the relative_strength_index """
+        r_cudf = gi.relative_strength_index(self._cudf_data['High'],
+                                            self._cudf_data['Low'], 10)
+        r_pandas = ti.relative_strength_index(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['RSI_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_mass_index(self):
+        """ test the mass_index """
+        r_cudf = gi.mass_index(self._cudf_data['High'],
+                               self._cudf_data['Low'], 9, 25)
+        r_pandas = ti.mass_index(self._pandas_data)
+        err = error_function(r_cudf, r_pandas['Mass Index'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_true_strength_index(self):
+        """ test the true_strength_index """
+        r_cudf = gi.true_strength_index(self._cudf_data['Close'], 5, 8)
+        r_pandas = ti.true_strength_index(self._pandas_data, 5, 8)
+        err = error_function(r_cudf, r_pandas['TSI_5_8'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_chaikin_oscillator(self):
+        """ test the chaikin_oscillator """
+        r_cudf = gi.chaikin_oscillator(self._cudf_data['High'],
+                                       self._cudf_data['Low'],
+                                       self._cudf_data['Close'],
+                                       self._cudf_data['Volume'],  3, 10)
+        r_pandas = ti.chaikin_oscillator(self._pandas_data)
+        err = error_function(r_cudf, r_pandas['Chaikin'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_money_flow_index(self):
+        """ test the money_flow_index """
+        r_cudf = gi.money_flow_index(self._cudf_data['High'],
+                                     self._cudf_data['Low'],
+                                     self._cudf_data['Close'],
+                                     self._cudf_data['Volume'], 10)
+        r_pandas = ti.money_flow_index(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['MFI_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_on_balance_volume(self):
+        """ test the on_balance_volume """
+        r_cudf = gi.on_balance_volume(self._cudf_data['Close'],
+                                      self._cudf_data['Volume'], 10)
+        r_pandas = ti.on_balance_volume(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['OBV_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_force_index(self):
+        """ test the force index """
+        r_cudf = gi.force_index(self._cudf_data['Close'],
+                                self._cudf_data['Volume'], 10)
+        r_pandas = ti.force_index(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['Force_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_ease_of_movement(self):
+        """ test the ease_of_movement """
+        r_cudf = gi.ease_of_movement(self._cudf_data['High'],
+                                     self._cudf_data['Low'],
+                                     self._cudf_data['Volume'], 10)
+        r_pandas = ti.ease_of_movement(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['EoM_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_ultimate_oscillator(self):
+        """ test the ultimate_oscillator """
+        r_cudf = gi.ultimate_oscillator(self._cudf_data['High'],
+                                        self._cudf_data['Low'],
+                                        self._cudf_data['Close'])
+        r_pandas = ti.ultimate_oscillator(self._pandas_data)
+        err = error_function(r_cudf, r_pandas['Ultimate_Osc'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_donchian_channel(self):
+        """ test the donchian_channel """
+        r_cudf = gi.donchian_channel(self._cudf_data['High'],
+                                     self._cudf_data['Low'], 10)
+        r_pandas = ti.donchian_channel(self._pandas_data, 10)
+        err = error_function(r_cudf[:-1], r_pandas['Donchian_10'][:-1])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_keltner_channel(self):
+        """ test the keltner_channel """
+        r_cudf = gi.keltner_channel(self._cudf_data['High'],
+                                    self._cudf_data['Low'],
+                                    self._cudf_data['Close'], 10)
+        r_pandas = ti.keltner_channel(self._pandas_data, 10)
+        err = error_function(r_cudf.KelChD, r_pandas['KelChD_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+        err = error_function(r_cudf.KelChM, r_pandas['KelChM_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+        err = error_function(r_cudf.KelChU, r_pandas['KelChU_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_coppock_curve(self):
+        """ test the coppock_curve """
+        r_cudf = gi.coppock_curve(self._cudf_data['Close'], 10)
+        r_pandas = ti.coppock_curve(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['Copp_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_accumulation_distribution(self):
+        """ test the accumulation_distribution """
+        r_cudf = gi.accumulation_distribution(self._cudf_data['High'],
+                                              self._cudf_data['Low'],
+                                              self._cudf_data['Close'],
+                                              self._cudf_data['Volume'], 10)
+        r_pandas = ti.accumulation_distribution(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['Acc/Dist_ROC_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_commodity_channel_index(self):
+        """ test the commodity_channel_index """
+        r_cudf = gi.commodity_channel_index(self._cudf_data['High'],
+                                            self._cudf_data['Low'],
+                                            self._cudf_data['Close'], 10)
+        r_pandas = ti.commodity_channel_index(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['CCI_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_momentum(self):
+        """ test the momentum """
+        r_cudf = gi.momentum(self._cudf_data['Close'], 10)
+        r_pandas = ti.momentum(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['Momentum_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_moving_average(self):
+        """ test the moving average """
+        r_cudf = gi.moving_average(self._cudf_data['Close'], 10)
+        r_pandas = ti.moving_average(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['MA_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_exponential_moving_average(self):
+        """ test the exponential moving average """
+        r_cudf = gi.exponential_moving_average(self._cudf_data['Close'], 10)
+        r_pandas = ti.exponential_moving_average(self._pandas_data, 10)
+        err = error_function(r_cudf, r_pandas['EMA_10'])
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/unit/test_pewm.py b/tests/unit/test_pewm.py
new file mode 100644
index 00000000..901a687f
--- /dev/null
+++ b/tests/unit/test_pewm.py
@@ -0,0 +1,81 @@
+'''
+Workflow Serialization Unit Tests
+
+To run unittests:
+
+# Using standard library unittest
+
+python -m unittest -v
+python -m unittest tests/unit/test_pewm.py -v
+
+or
+
+python -m unittest discover <test_directory>
+python -m unittest discover -s <directory> -p 'test_*.py'
+
+# Using pytest
+# "conda install pytest" or "pip install pytest"
+pytest -v tests
+pytest -v tests/unit/test_pewm.py
+
+'''
+import pandas as pd
+import unittest
+import cudf
+from .utils import make_orderer, error_function
+from gquant.cuindicator import PEwm
+import numpy as np
+
+ordered, compare = make_orderer()
+unittest.defaultTestLoader.sortTestMethodsUsing = compare
+
+
+class TestPEwm(unittest.TestCase):
+
+    def setUp(self):
+        random_array = np.arange(20, dtype=np.float64)
+        indicator = np.zeros(20, dtype=np.int32)
+        indicator[0] = 1
+        indicator[10] = 1
+        df = cudf.dataframe.DataFrame()
+        df['in'] = random_array
+        df['indicator'] = indicator
+
+        pdf = pd.DataFrame()
+        pdf['in0'] = random_array[0:10]
+        pdf['in1'] = random_array[10:]
+
+        # ignore importlib warnings.
+        self._pandas_data = pdf
+        self._cudf_data = df
+
+    def tearDown(self):
+        pass
+
+    @ordered
+    def test_pewm(self):
+        '''Test portfolio ewm method'''
+        self._cudf_data['ewma'] = PEwm(3,
+                                       self._cudf_data['in'],
+                                       self._cudf_data[
+                                           'indicator'].data.to_gpu_array(),
+                                       thread_tile=2,
+                                       number_of_threads=2).mean()
+        gpu_array = self._cudf_data['ewma']
+        gpu_result = gpu_array[0:10]
+        cpu_result = self._pandas_data['in0'].ewm(span=3,
+                                                  min_periods=3).mean()
+        err = error_function(gpu_result, cpu_result)
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+        cpu_result = self._pandas_data['in1'].ewm(span=3,
+                                                  min_periods=3).mean()
+        gpu_result = gpu_array[10:20]
+        err = error_function(gpu_result, cpu_result)
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/unit/test_rolling.py b/tests/unit/test_rolling.py
new file mode 100644
index 00000000..50d03422
--- /dev/null
+++ b/tests/unit/test_rolling.py
@@ -0,0 +1,107 @@
+'''
+Workflow Serialization Unit Tests
+
+To run unittests:
+
+# Using standard library unittest
+
+python -m unittest -v
+python -m unittest tests/unit/test_rolling.py -v
+
+or
+
+python -m unittest discover <test_directory>
+python -m unittest discover -s <directory> -p 'test_*.py'
+
+# Using pytest
+# "conda install pytest" or "pip install pytest"
+pytest -v tests
+pytest -v tests/unit/test_rolling.py
+
+'''
+import pandas as pd
+import unittest
+import cudf
+from gquant.cuindicator import Rolling, Ewm
+from .utils import make_orderer, error_function
+import numpy as np
+
+ordered, compare = make_orderer()
+unittest.defaultTestLoader.sortTestMethodsUsing = compare
+
+
+class TestRolling(unittest.TestCase):
+
+    def setUp(self):
+        array_len = int(1e4)
+        self.average_window = 300
+        random_array = np.random.rand(array_len)
+
+        df = cudf.dataframe.DataFrame()
+        df['in'] = random_array
+
+        pdf = pd.DataFrame()
+        pdf['in'] = random_array
+
+        # ignore importlib warnings.
+        self._pandas_data = pdf
+        self._cudf_data = df
+
+    def tearDown(self):
+        pass
+
+    @ordered
+    def test_rolling_functions(self):
+        '''Test rolling window method'''
+
+        gpu_result = Rolling(self.average_window, self._cudf_data['in']).mean()
+        cpu_result = self._pandas_data[
+            'in'].rolling(self.average_window).mean()
+        err = error_function(cudf.Series(gpu_result), cpu_result)
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+        gpu_result = Rolling(self.average_window, self._cudf_data['in']).max()
+        cpu_result = self._pandas_data['in'].rolling(self.average_window).max()
+        err = error_function(cudf.Series(gpu_result), cpu_result)
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+        gpu_result = Rolling(self.average_window, self._cudf_data['in']).min()
+        cpu_result = self._pandas_data['in'].rolling(self.average_window).min()
+        err = error_function(cudf.Series(gpu_result), cpu_result)
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+        gpu_result = Rolling(self.average_window, self._cudf_data['in']).sum()
+        cpu_result = self._pandas_data['in'].rolling(self.average_window).sum()
+        err = error_function(cudf.Series(gpu_result), cpu_result)
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+        gpu_result = Rolling(self.average_window, self._cudf_data['in']).std()
+        cpu_result = self._pandas_data['in'].rolling(self.average_window).std()
+        err = error_function(cudf.Series(gpu_result), cpu_result)
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+        gpu_result = Rolling(self.average_window, self._cudf_data['in']).var()
+        cpu_result = self._pandas_data['in'].rolling(self.average_window).var()
+        err = error_function(cudf.Series(gpu_result), cpu_result)
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_ewm_functions(self):
+        '''Test exponential moving average method'''
+        gpu_result = Ewm(self.average_window, self._cudf_data['in']).mean()
+        cpu_result = self._pandas_data[
+            'in'].ewm(span=self.average_window,
+                      min_periods=self.average_window).mean()
+        err = error_function(cudf.Series(gpu_result), cpu_result)
+        msg = "bad error %f\n" % (err,)
+        self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/unit/test_util.py b/tests/unit/test_util.py
new file mode 100644
index 00000000..7f24b7e1
--- /dev/null
+++ b/tests/unit/test_util.py
@@ -0,0 +1,75 @@
+'''
+Workflow Serialization Unit Tests
+
+To run unittests:
+
+# Using standard library unittest
+
+python -m unittest -v
+python -m unittest tests/unit/test_util.py -v
+
+or
+
+python -m unittest discover <test_directory>
+python -m unittest discover -s <directory> -p 'test_*.py'
+
+# Using pytest
+# "conda install pytest" or "pip install pytest"
+pytest -v tests
+pytest -v tests/unit/test_util.py
+
+'''
+import pandas as pd
+import unittest
+import cudf
+from gquant.cuindicator import shift, diff
+import numpy as np
+from .utils import make_orderer, error_function
+
+ordered, compare = make_orderer()
+unittest.defaultTestLoader.sortTestMethodsUsing = compare
+
+
+class TestUtil(unittest.TestCase):
+
+    def setUp(self):
+        array_len = int(1e4)
+        self.average_window = 300
+        random_array = np.random.rand(array_len)
+
+        df = cudf.dataframe.DataFrame()
+        df['in'] = random_array
+
+        pdf = pd.DataFrame()
+        pdf['in'] = random_array
+
+        # ignore importlib warnings.
+        self._pandas_data = pdf
+        self._cudf_data = df
+
+    def tearDown(self):
+        pass
+
+    @ordered
+    def test_diff_functions(self):
+        '''Test diff method'''
+        for window in [-1, -2, -3, 1, 2, 3]:
+            gpu_result = diff(self._cudf_data['in'], window)
+            cpu_result = self._pandas_data['in'].diff(window)
+            err = error_function(cudf.Series(gpu_result), cpu_result)
+            msg = "bad error %f\n" % (err,)
+            self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+    @ordered
+    def test_shift_functions(self):
+        '''Test shift method'''
+        for window in [-1, -2, -3, 1, 2, 3]:
+            gpu_result = shift(self._cudf_data['in'], window)
+            cpu_result = self._pandas_data['in'].shift(window)
+            err = error_function(cudf.Series(gpu_result), cpu_result)
+            msg = "bad error %f\n" % (err,)
+            self.assertTrue(np.isclose(err, 0, atol=1e-6), msg)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/unit/test_workflow_serialization.py b/tests/unit/test_workflow_serialization.py
index 3f2a3868..69135029 100644
--- a/tests/unit/test_workflow_serialization.py
+++ b/tests/unit/test_workflow_serialization.py
@@ -23,30 +23,18 @@
 import warnings
 from io import StringIO
 import yaml
-import shutil, tempfile
+import shutil
+import tempfile
 import unittest
 from difflib import context_diff
-
-
-# --------------------------------------------------------- Keep tests in order
-def make_orderer():
-    order = {}
-
-    def ordered(f):
-        order[f.__name__] = len(order)
-        return f
-
-    def compare(a, b):
-        return [1, -1][order[a] < order[b]]
-
-    return ordered, compare
+from .utils import make_orderer
 
 ordered, compare = make_orderer()
 unittest.defaultTestLoader.sortTestMethodsUsing = compare
 
 # ------------------------------------------- Workflow Serialization Test Cases
 WORKFLOW_YAML = \
-'''- id: points
+    '''- id: points
   type: PointNode
   conf: {}
   inputs: []
@@ -122,13 +110,13 @@ def test_save_workflow(self):
         cdiff_empty = cdiff == []
 
         err_msg = 'Workflow yaml contents do not match expected results.\n'\
-        'SHOULD HAVE SAVED:\n\n'\
-        '{wyaml}\n\n'\
-        'INSTEAD FILE CONTAINS:\n\n'\
-        '{fcont}\n\n'\
-        'DIFF:\n\n'\
-        '{diff}'.format(wyaml=WORKFLOW_YAML, fcont=workflow_str,
-                        diff=''.join(cdiff))
+            'SHOULD HAVE SAVED:\n\n'\
+            '{wyaml}\n\n'\
+            'INSTEAD FILE CONTAINS:\n\n'\
+            '{fcont}\n\n'\
+            'DIFF:\n\n'\
+            '{diff}'.format(wyaml=WORKFLOW_YAML, fcont=workflow_str,
+                            diff=''.join(cdiff))
 
         self.assertTrue(cdiff_empty, err_msg)
 
@@ -156,10 +144,10 @@ def test_load_workflow(self):
             yf.seek(0)
 
             err_msg = 'Load workflow failed. Missing expected task items.\n'\
-            'EXPECTED WORKFLOW YAML:\n\n'\
-            '{wyaml}\n\n'\
-            'GOT TASKS FORMATTED AS YAML:\n\n'\
-            '{tlist}\n\n'.format(wyaml=WORKFLOW_YAML, tlist=yf.read())
+                'EXPECTED WORKFLOW YAML:\n\n'\
+                '{wyaml}\n\n'\
+                'GOT TASKS FORMATTED AS YAML:\n\n'\
+                '{tlist}\n\n'.format(wyaml=WORKFLOW_YAML, tlist=yf.read())
 
             self.assertTrue(all_tasks_exist, err_msg)
 
diff --git a/tests/unit/testdata.csv.gz b/tests/unit/testdata.csv.gz
new file mode 100644
index 00000000..bceee207
Binary files /dev/null and b/tests/unit/testdata.csv.gz differ
diff --git a/tests/unit/utils.py b/tests/unit/utils.py
new file mode 100644
index 00000000..612dbc71
--- /dev/null
+++ b/tests/unit/utils.py
@@ -0,0 +1,38 @@
+import numpy as np
+
+
+def make_orderer():
+    """Keep tests in order"""
+    order = {}
+
+    def ordered(f):
+        order[f.__name__] = len(order)
+        return f
+
+    def compare(a, b):
+        return [1, -1][order[a] < order[b]]
+
+    return ordered, compare
+
+
+def error_function(gpu_series, result_series):
+    """
+    utility function to compare GPU array vs CPU array
+    Parameters
+    ------
+    gpu_series: cudf.Series
+        GPU computation result series
+    result_series: pandas.Series
+        Pandas computation result series
+
+    Returns
+    -----
+    double
+        maximum error of the two arrays
+    """
+    gpu_arr = gpu_series.to_array(fillna='pandas')
+    pan_arr = result_series.values
+    gpu_arr = gpu_arr[~np.isnan(gpu_arr) & ~np.isinf(gpu_arr)]
+    pan_arr = pan_arr[~np.isnan(pan_arr) & ~np.isinf(pan_arr)]
+    err = np.abs(gpu_arr - pan_arr).max()
+    return err