Merge pull request #104 from antinucleon/master

merge

python/mxnet/__init__.py

@@ -21,6 +21,7 @@
 from . import optimizer
 from . import model
 from . import initializer
+from . import visualization
 import atexit
 
 __version__ = "0.1.0"

python/mxnet/metric.py

@@ -1,14 +1,14 @@
+# pylint: disable=invalid-name
 """Online evaluation metric module."""
 import numpy as np
-from .ndarray import NDArray
 
 class EvalMetric(object):
     """Base class of all evaluation metrics."""
     def __init__(self, name):
         self.name = name
         self.reset()
 
-    def update(pred, label):
+    def update(self, pred, label):
         """Update the internal evaluation.
 
         Parameters
@@ -40,6 +40,7 @@ def get(self):
 
 
 class Accuracy(EvalMetric):
+    """Calculate accuracy"""
     def __init__(self):
         super(Accuracy, self).__init__('accuracy')
 

python/mxnet/model.py

@@ -1,11 +1,12 @@
-# pylint: skip-file
+# pylint: disable=fixme, invalid-name, too-many-arguments, too-many-locals, no-member
+# pylint: disable=too-many-branches, too-many-statements, unused-argument, unused-variable
+"""MXNet model module"""
 import numpy as np
 import time
 from . import io
 from . import nd
 from . import optimizer as opt
 from . import metric
-from .symbol import Symbol
 from .context import Context
 from .initializer import Xavier
 
@@ -20,7 +21,7 @@
 
 
 def _train(symbol, ctx, input_shape,
-           arg_params, aux_states,
+           arg_params, aux_params,
            begin_round, end_round, optimizer,
            train_data, eval_data=None, eval_metric=None,
            iter_end_callback=None, verbose=True):
@@ -40,7 +41,7 @@ def _train(symbol, ctx, input_shape,
     arg_params : dict of str to NDArray
         Model parameter, dict of name to NDArray of net's weights.
 
-    aux_states : dict of str to NDArray
+    aux_params : dict of str to NDArray
         Model parameter, dict of name to NDArray of net's auxiliary states.
 
     begin_round : int
@@ -81,16 +82,16 @@ def _train(symbol, ctx, input_shape,
     grad_arrays = train_exec.grad_arrays
     aux_arrays = train_exec.aux_arrays
     # copy initialized parameters to executor parameters
-    for key, weight in zip(arg_names, arg_arrays):
+    for key, weight in list(zip(arg_names, arg_arrays)):
         if key in arg_params:
             arg_params[key].copyto(weight)
-    for key, weight in zip(aux_names, aux_arrays):
+    for key, weight in list(zip(aux_names, aux_arrays)):
         if key in aux_params:
             aux_params[key].copyto(weight)
     # setup helper data structures
     label_array = None
     data_array = None
-    for name, arr in zip(symbol.list_arguments(),  arg_arrays):
+    for name, arr in list(zip(symbol.list_arguments(), arg_arrays)):
         if name.endswith('label'):
             assert label_array is None
             label_array = arr
@@ -151,10 +152,10 @@ def _train(symbol, ctx, input_shape,
             for key, weight, gard in arg_blocks:
                 if key in arg_params:
                     weight.copyto(arg_params[key])
-            for key, arr in zip(aux_names, aux_states):
-                arr.copyto(aux_states[key])
+            for key, arr in list(zip(aux_names, aux_arrays)):
+                arr.copyto(aux_params[key])
         if iter_end_callback:
-            iter_end_callback(i, arg_params, aux_states)
+            iter_end_callback(i, arg_params, aux_arrays)
     # end of the function
     return
 
@@ -224,11 +225,11 @@ def _init_params(self):
         arg_shapes, _, aux_shapes = self.symbol.infer_shape(data=self.input_shape)
         if self.arg_params is None:
             arg_names = self.symbol.list_arguments()
-            self.arg_params = {k : nd.zeros(s) for k, s in zip(arg_names, arg_shapes)
+            self.arg_params = {k : nd.zeros(s) for k, s in list(zip(arg_names, arg_shapes))
                                if not is_data_arg(k)}
         if self.aux_states is None:
             aux_names = self.symbol.list_auxiliary_states()
-            self.aux_states = {k : nd.zeros(s) for k, s in zip(aux_names, aux_shapes)}
+            self.aux_states = {k : nd.zeros(s) for k, s in list(zip(aux_names, aux_shapes))}
         for k, v in self.arg_params.items():
             self.initializer(k, v)
         for k, v in self.aux_states.items():
@@ -241,7 +242,7 @@ def _init_predictor(self):
         # for now only use the first device
         pred_exec = self.symbol.simple_bind(
             self.ctx[0], grad_req='null', data=self.input_shape)
-        for name, value in zip(self.symbol.list_arguments(), pred_exec.arg_arrays):
+        for name, value in list(zip(self.symbol.list_arguments(), pred_exec.arg_arrays)):
             if name not in self.arg_datas:
                 assert name in self.arg_params
                 self.arg_params[name].copyto(value)

python/mxnet/optimizer.py

@@ -1,4 +1,4 @@
-# pylint: skip-file
+# pylint: disable=fixme, invalid-name
 """Common Optimization algorithms with regularizations."""
 from .ndarray import NDArray, zeros
 

python/mxnet/symbol.py

@@ -423,7 +423,6 @@ def simple_bind(self, ctx, grad_req='write', **kwargs):
         arg_ndarrays = [zeros(shape, ctx) for shape in arg_shapes]
 
         if grad_req != 'null':
-            req = {}
             grad_ndarrays = {}
             for name, shape in zip(self.list_arguments(), arg_shapes):
                 if not (name.endswith('data') or name.endswith('label')):

python/mxnet/visualization.py

@@ -0,0 +1,137 @@
+# coding: utf-8
+# pylint: disable=invalid-name, protected-access, too-many-locals, fixme
+# pylint: disable=unused-argument, too-many-branches, too-many-statements
+"""Visualization module"""
+from .symbol import Symbol
+import json
+import re
+import copy
+
+
+def _str2tuple(string):
+    """convert shape string to list, internal use only
+
+    Parameters
+    ----------
+    string: str
+        shape string
+
+    Returns
+    -------
+    list of str to represent shape
+    """
+    return re.findall(r"\d+", string)
+
+
+def network2dot(title, symbol, shape=None):
+    """convert symbol to dot object for visualization
+
+    Parameters
+    ----------
+    title: str
+        title of the dot graph
+    symbol: Symbol
+        symbol to be visualized
+    shape: TODO
+        TODO
+
+    Returns
+    ------
+    dot: Diagraph
+        dot object of symbol
+    """
+    # todo add shape support
+    try:
+        from graphviz import Digraph
+    except:
+        raise ImportError("Draw network requires graphviz library")
+    if not isinstance(symbol, Symbol):
+        raise TypeError("symbol must be Symbol")
+    conf = json.loads(symbol.tojson())
+    nodes = conf["nodes"]
+    heads = set(conf["heads"][0])  # TODO(xxx): check careful
+    node_attr = {"shape": "box", "fixedsize": "true",
+                 "width": "1.3", "height": "0.8034", "style": "filled"}
+    dot = Digraph(name=title)
+    # make nodes
+    for i in range(len(nodes)):
+        node = nodes[i]
+        op = node["op"]
+        name = "%s_%d" % (op, i)
+        # input data
+        if i in heads and op == "null":
+            label = node["name"]
+            attr = copy.deepcopy(node_attr)
+            dot.node(name=name, label=label, **attr)
+        if op == "null":
+            continue
+        elif op == "Convolution":
+            label = "Convolution\n%sx%s/%s, %s" % (_str2tuple(node["param"]["kernel"])[0],
+                                                   _str2tuple(node["param"]["kernel"])[1],
+                                                   _str2tuple(node["param"]["stride"])[0],
+                                                   node["param"]["num_filter"])
+            attr = copy.deepcopy(node_attr)
+            attr["color"] = "royalblue1"
+            dot.node(name=name, label=label, **attr)
+        elif op == "FullyConnected":
+            label = "FullyConnected\n%s" % node["param"]["num_hidden"]
+            attr = copy.deepcopy(node_attr)
+            attr["color"] = "royalblue1"
+            dot.node(name=name, label=label, **attr)
+        elif op == "BatchNorm":
+            label = "BatchNorm"
+            attr = copy.deepcopy(node_attr)
+            attr["color"] = "orchid1"
+            dot.node(name=name, label=label, **attr)
+        elif op == "Concat":
+            label = "Concat"
+            attr = copy.deepcopy(node_attr)
+            attr["color"] = "seagreen1"
+            dot.node(name=name, label=label, **attr)
+        elif op == "Flatten":
+            label = "Flatten"
+            attr = copy.deepcopy(node_attr)
+            attr["color"] = "seagreen1"
+            dot.node(name=name, label=label, **attr)
+        elif op == "Reshape":
+            label = "Reshape"
+            attr = copy.deepcopy(node_attr)
+            attr["color"] = "seagreen1"
+            dot.node(name=name, label=label, **attr)
+        elif op == "Pooling":
+            label = "Pooling\n%s, %sx%s/%s" % (node["param"]["pool_type"],
+                                               _str2tuple(node["param"]["kernel"])[0],
+                                               _str2tuple(node["param"]["kernel"])[1],
+                                               _str2tuple(node["param"]["stride"])[0])
+            attr = copy.deepcopy(node_attr)
+            attr["color"] = "firebrick2"
+            dot.node(name=name, label=label, **attr)
+        elif op == "Activation" or op == "LeakyReLU":
+            label = "%s\n%s" % (op, node["param"]["act_type"])
+            attr = copy.deepcopy(node_attr)
+            attr["color"] = "salmon"
+            dot.node(name=name, label=label, **attr)
+        else:
+            label = op
+            attr = copy.deepcopy(node_attr)
+            attr["color"] = "olivedrab1"
+            dot.node(name=name, label=label, **attr)
+
+    # add edges
+    for i in range(len(nodes)):
+        node = nodes[i]
+        op = node["op"]
+        name = "%s_%d" % (op, i)
+        if op == "null":
+            continue
+        else:
+            inputs = node["inputs"]
+            for item in inputs:
+                input_node = nodes[item[0]]
+                input_name = "%s_%d" % (input_node["op"], item[0])
+                if input_node["op"] != "null" or item[0] in heads:
+                    # add shape into label
+                    attr = {"dir": "back"}
+                    dot.edge(tail_name=name, head_name=input_name, **attr)
+
+    return dot