Simplifying mxnet.gluon.block APIs

python/mxnet/contrib/amp/amp.py

@@ -686,7 +686,8 @@ def convert_hybrid_block(block, target_dtype="float16", target_dtype_ops=None,
     # If dtype for the param was set in the json, cast the
     # param to this dtype
     attr_dict = converted_sym.attr_dict()
-    for name, param in block.collect_params().items():
+    for param in block.collect_params().values():
+        name = param.name
         if name in arg_names:
             arg_dict['arg:%s'%name] = param._reduce()
             if name in attr_dict and "__dtype__" in attr_dict[name]:
@@ -719,7 +720,7 @@ def convert_hybrid_block(block, target_dtype="float16", target_dtype_ops=None,
         if aux_param_name in arg_dict and param.dtype != arg_dict[aux_param_name].dtype:
             param.cast(arg_dict[aux_param_name].dtype)
 
-    ret.collect_params().load_dict(arg_dict, ctx=ctx)
+    ret.load_dict(arg_dict, ctx=ctx)
     return ret
 
 def list_lp16_ops(target_dtype):

python/mxnet/gluon/contrib/cnn/conv_layers.py

@@ -23,6 +23,7 @@
 
 from .... import symbol
 from ...block import HybridBlock
+from ...parameter import Parameter
 from ....base import numeric_types
 from ...nn import Activation
 
@@ -103,80 +104,79 @@ def __init__(self, channels, kernel_size=(1, 1), strides=(1, 1), padding=(0, 0),
                  num_deformable_group=1, layout='NCHW', use_bias=True, in_channels=0, activation=None,
                  weight_initializer=None, bias_initializer='zeros',
                  offset_weight_initializer='zeros', offset_bias_initializer='zeros', offset_use_bias=True,
-                 op_name='DeformableConvolution', adj=None, prefix=None, params=None):
-        super(DeformableConvolution, self).__init__(prefix=prefix, params=params)
-        with self.name_scope():
-            self._channels = channels
-            self._in_channels = in_channels
-
-            assert layout in ('NCHW', 'NHWC'), "Only supports 'NCHW' and 'NHWC' layout for now"
-            if isinstance(kernel_size, numeric_types):
-                kernel_size = (kernel_size,) * 2
-            if isinstance(strides, numeric_types):
-                strides = (strides,) * len(kernel_size)
-            if isinstance(padding, numeric_types):
-                padding = (padding,) * len(kernel_size)
-            if isinstance(dilation, numeric_types):
-                dilation = (dilation,) * len(kernel_size)
-            self._op_name = op_name
-
-            offset_channels = 2 * kernel_size[0] * kernel_size[1] * num_deformable_group
-            self._kwargs_offset = {
-                'kernel': kernel_size, 'stride': strides, 'dilate': dilation,
-                'pad': padding, 'num_filter': offset_channels, 'num_group': groups,
-                'no_bias': not offset_use_bias, 'layout': layout}
-
-            self._kwargs_deformable_conv = {
-                'kernel': kernel_size, 'stride': strides, 'dilate': dilation,
-                'pad': padding, 'num_filter': channels, 'num_group': groups,
-                'num_deformable_group': num_deformable_group,
-                'no_bias': not use_bias, 'layout': layout}
-
-            if adj:
-                self._kwargs_offset['adj'] = adj
-                self._kwargs_deformable_conv['adj'] = adj
-
-            dshape = [0] * (len(kernel_size) + 2)
-            dshape[layout.find('N')] = 1
-            dshape[layout.find('C')] = in_channels
-
-            op = getattr(symbol, 'Convolution')
-            offset = op(symbol.var('data', shape=dshape), **self._kwargs_offset)
-
-            offsetshapes = offset.infer_shape_partial()[0]
-
-            self.offset_weight = self.params.get('offset_weight', shape=offsetshapes[1],
-                                                 init=offset_weight_initializer,
-                                                 allow_deferred_init=True)
-
-            if offset_use_bias:
-                self.offset_bias = self.params.get('offset_bias', shape=offsetshapes[2],
-                                                   init=offset_bias_initializer,
-                                                   allow_deferred_init=True)
-            else:
-                self.offset_bias = None
-
-            deformable_conv_weight_shape = [0] * (len(kernel_size) + 2)
-            deformable_conv_weight_shape[0] = channels
-            deformable_conv_weight_shape[2] = kernel_size[0]
-            deformable_conv_weight_shape[3] = kernel_size[1]
-
-            self.deformable_conv_weight = self.params.get('deformable_conv_weight',
-                                                          shape=deformable_conv_weight_shape,
-                                                          init=weight_initializer,
-                                                          allow_deferred_init=True)
-
-            if use_bias:
-                self.deformable_conv_bias = self.params.get('deformable_conv_bias', shape=(channels,),
-                                                            init=bias_initializer,
-                                                            allow_deferred_init=True)
-            else:
-                self.deformable_conv_bias = None
-
-            if activation:
-                self.act = Activation(activation, prefix=activation + '_')
-            else:
-                self.act = None
+                 op_name='DeformableConvolution', adj=None):
+        super(DeformableConvolution, self).__init__()
+        self._channels = channels
+        self._in_channels = in_channels
+
+        assert layout in ('NCHW', 'NHWC'), "Only supports 'NCHW' and 'NHWC' layout for now"
+        if isinstance(kernel_size, numeric_types):
+            kernel_size = (kernel_size,) * 2
+        if isinstance(strides, numeric_types):
+            strides = (strides,) * len(kernel_size)
+        if isinstance(padding, numeric_types):
+            padding = (padding,) * len(kernel_size)
+        if isinstance(dilation, numeric_types):
+            dilation = (dilation,) * len(kernel_size)
+        self._op_name = op_name
+
+        offset_channels = 2 * kernel_size[0] * kernel_size[1] * num_deformable_group
+        self._kwargs_offset = {
+            'kernel': kernel_size, 'stride': strides, 'dilate': dilation,
+            'pad': padding, 'num_filter': offset_channels, 'num_group': groups,
+            'no_bias': not offset_use_bias, 'layout': layout}
+
+        self._kwargs_deformable_conv = {
+            'kernel': kernel_size, 'stride': strides, 'dilate': dilation,
+            'pad': padding, 'num_filter': channels, 'num_group': groups,
+            'num_deformable_group': num_deformable_group,
+            'no_bias': not use_bias, 'layout': layout}
+
+        if adj:
+            self._kwargs_offset['adj'] = adj
+            self._kwargs_deformable_conv['adj'] = adj
+
+        dshape = [0] * (len(kernel_size) + 2)
+        dshape[layout.find('N')] = 1
+        dshape[layout.find('C')] = in_channels
+
+        op = getattr(symbol, 'Convolution')
+        offset = op(symbol.var('data', shape=dshape), **self._kwargs_offset)
+
+        offsetshapes = offset.infer_shape_partial()[0]
+
+        self.offset_weight = Parameter('offset_weight', shape=offsetshapes[1],
+                                       init=offset_weight_initializer,
+                                       allow_deferred_init=True)
+
+        if offset_use_bias:
+            self.offset_bias = Parameter('offset_bias', shape=offsetshapes[2],
+                                         init=offset_bias_initializer,
+                                         allow_deferred_init=True)
+        else:
+            self.offset_bias = None
+
+        deformable_conv_weight_shape = [0] * (len(kernel_size) + 2)
+        deformable_conv_weight_shape[0] = channels
+        deformable_conv_weight_shape[2] = kernel_size[0]
+        deformable_conv_weight_shape[3] = kernel_size[1]
+
+        self.deformable_conv_weight = Parameter('deformable_conv_weight',
+                                                shape=deformable_conv_weight_shape,
+                                                init=weight_initializer,
+                                                allow_deferred_init=True)
+
+        if use_bias:
+            self.deformable_conv_bias = Parameter('deformable_conv_bias', shape=(channels,),
+                                                  init=bias_initializer,
+                                                  allow_deferred_init=True)
+        else:
+            self.deformable_conv_bias = None
+
+        if activation:
+            self.act = Activation(activation)
+        else:
+            self.act = None
 
     def hybrid_forward(self, F, x, offset_weight, deformable_conv_weight, offset_bias=None, deformable_conv_bias=None):
         if offset_bias is None:
@@ -296,81 +296,80 @@ def __init__(self, channels, kernel_size=(1, 1), strides=(1, 1), padding=(0, 0),
                  num_deformable_group=1, layout='NCHW', use_bias=True, in_channels=0, activation=None,
                  weight_initializer=None, bias_initializer='zeros',
                  offset_weight_initializer='zeros', offset_bias_initializer='zeros', offset_use_bias=True,
-                 op_name='ModulatedDeformableConvolution', adj=None, prefix=None, params=None):
-        super(ModulatedDeformableConvolution, self).__init__(prefix=prefix, params=params)
-        with self.name_scope():
-            self._channels = channels
-            self._in_channels = in_channels
-
-            assert layout in ('NCHW', 'NHWC'), "Only supports 'NCHW' and 'NHWC' layout for now"
-            if isinstance(kernel_size, numeric_types):
-                kernel_size = (kernel_size,) * 2
-            if isinstance(strides, numeric_types):
-                strides = (strides,) * len(kernel_size)
-            if isinstance(padding, numeric_types):
-                padding = (padding,) * len(kernel_size)
-            if isinstance(dilation, numeric_types):
-                dilation = (dilation,) * len(kernel_size)
-            self._op_name = op_name
-
-            offset_channels = num_deformable_group * 3 * kernel_size[0] * kernel_size[1]
-            self.offset_split_index = num_deformable_group * 2 * kernel_size[0] * kernel_size[1]
-            self._kwargs_offset = {
-                'kernel': kernel_size, 'stride': strides, 'dilate': dilation,
-                'pad': padding, 'num_filter': offset_channels, 'num_group': groups,
-                'no_bias': not offset_use_bias, 'layout': layout}
-
-            self._kwargs_deformable_conv = {
-                'kernel': kernel_size, 'stride': strides, 'dilate': dilation,
-                'pad': padding, 'num_filter': channels, 'num_group': groups,
-                'num_deformable_group': num_deformable_group,
-                'no_bias': not use_bias, 'layout': layout}
-
-            if adj:
-                self._kwargs_offset['adj'] = adj
-                self._kwargs_deformable_conv['adj'] = adj
-
-            deformable_conv_weight_shape = [0] * (len(kernel_size) + 2)
-            deformable_conv_weight_shape[0] = channels
-            deformable_conv_weight_shape[2] = kernel_size[0]
-            deformable_conv_weight_shape[3] = kernel_size[1]
-
-            self.deformable_conv_weight = self.params.get('deformable_conv_weight',
-                                                          shape=deformable_conv_weight_shape,
-                                                          init=weight_initializer,
-                                                          allow_deferred_init=True)
-
-            if use_bias:
-                self.deformable_conv_bias = self.params.get('deformable_conv_bias', shape=(channels,),
-                                                            init=bias_initializer,
-                                                            allow_deferred_init=True)
-            else:
-                self.deformable_conv_bias = None
-
-            dshape = [0] * (len(kernel_size) + 2)
-            dshape[layout.find('N')] = 1
-            dshape[layout.find('C')] = in_channels
-
-            op = getattr(symbol, 'Convolution')
-            offset = op(symbol.var('data', shape=dshape), **self._kwargs_offset)
-
-            offsetshapes = offset.infer_shape_partial()[0]
-
-            self.offset_weight = self.params.get('offset_weight', shape=offsetshapes[1],
-                                                 init=offset_weight_initializer,
-                                                 allow_deferred_init=True)
-
-            if offset_use_bias:
-                self.offset_bias = self.params.get('offset_bias', shape=offsetshapes[2],
-                                                   init=offset_bias_initializer,
-                                                   allow_deferred_init=True)
-            else:
-                self.offset_bias = None
-
-            if activation:
-                self.act = Activation(activation, prefix=activation + '_')
-            else:
-                self.act = None
+                 op_name='ModulatedDeformableConvolution', adj=None):
+        super(ModulatedDeformableConvolution, self).__init__()
+        self._channels = channels
+        self._in_channels = in_channels
+
+        assert layout in ('NCHW', 'NHWC'), "Only supports 'NCHW' and 'NHWC' layout for now"
+        if isinstance(kernel_size, numeric_types):
+            kernel_size = (kernel_size,) * 2
+        if isinstance(strides, numeric_types):
+            strides = (strides,) * len(kernel_size)
+        if isinstance(padding, numeric_types):
+            padding = (padding,) * len(kernel_size)
+        if isinstance(dilation, numeric_types):
+            dilation = (dilation,) * len(kernel_size)
+        self._op_name = op_name
+
+        offset_channels = num_deformable_group * 3 * kernel_size[0] * kernel_size[1]
+        self.offset_split_index = num_deformable_group * 2 * kernel_size[0] * kernel_size[1]
+        self._kwargs_offset = {
+            'kernel': kernel_size, 'stride': strides, 'dilate': dilation,
+            'pad': padding, 'num_filter': offset_channels, 'num_group': groups,
+            'no_bias': not offset_use_bias, 'layout': layout}
+
+        self._kwargs_deformable_conv = {
+            'kernel': kernel_size, 'stride': strides, 'dilate': dilation,
+            'pad': padding, 'num_filter': channels, 'num_group': groups,
+            'num_deformable_group': num_deformable_group,
+            'no_bias': not use_bias, 'layout': layout}
+
+        if adj:
+            self._kwargs_offset['adj'] = adj
+            self._kwargs_deformable_conv['adj'] = adj
+
+        deformable_conv_weight_shape = [0] * (len(kernel_size) + 2)
+        deformable_conv_weight_shape[0] = channels
+        deformable_conv_weight_shape[2] = kernel_size[0]
+        deformable_conv_weight_shape[3] = kernel_size[1]
+
+        self.deformable_conv_weight = Parameter('deformable_conv_weight',
+                                                shape=deformable_conv_weight_shape,
+                                                init=weight_initializer,
+                                                allow_deferred_init=True)
+
+        if use_bias:
+            self.deformable_conv_bias = Parameter('deformable_conv_bias', shape=(channels,),
+                                                  init=bias_initializer,
+                                                  allow_deferred_init=True)
+        else:
+            self.deformable_conv_bias = None
+
+        dshape = [0] * (len(kernel_size) + 2)
+        dshape[layout.find('N')] = 1
+        dshape[layout.find('C')] = in_channels
+
+        op = getattr(symbol, 'Convolution')
+        offset = op(symbol.var('data', shape=dshape), **self._kwargs_offset)
+
+        offsetshapes = offset.infer_shape_partial()[0]
+
+        self.offset_weight = Parameter('offset_weight', shape=offsetshapes[1],
+                                       init=offset_weight_initializer,
+                                       allow_deferred_init=True)
+
+        if offset_use_bias:
+            self.offset_bias = Parameter('offset_bias', shape=offsetshapes[2],
+                                         init=offset_bias_initializer,
+                                         allow_deferred_init=True)
+        else:
+            self.offset_bias = None
+
+        if activation:
+            self.act = Activation(activation)
+        else:
+            self.act = None
 
     def hybrid_forward(self, F, x, offset_weight, deformable_conv_weight, offset_bias=None, deformable_conv_bias=None):
         if offset_bias is None:

python/mxnet/gluon/contrib/data/vision/dataloader.py

@@ -92,7 +92,7 @@ def create_image_augment(data_shape, resize=0, rand_crop=False, rand_resize=Fals
     """
     if inter_method == 10:
         inter_method = np.random.randint(0, 5)
-    augmenter = HybridSequential('default_img_augment_')
+    augmenter = HybridSequential()
     if resize > 0:
         augmenter.add(transforms.image.Resize(resize, interpolation=inter_method))
     crop_size = (data_shape[2], data_shape[1])
@@ -220,9 +220,9 @@ def __init__(self, batch_size, data_shape, path_imgrec=None, path_imglist=None,
             augmenter = create_image_augment(data_shape, **kwargs)
         elif isinstance(aug_list, list):
             if all([isinstance(a, HybridBlock) for a in aug_list]):
-                augmenter = HybridSequential('user_img_augment_')
+                augmenter = HybridSequential()
             else:
-                augmenter = Sequential('user_img_augment_')
+                augmenter = Sequential()
             for aug in aug_list:
                 augmenter.add(aug)
         elif isinstance(aug_list, Block):
@@ -316,7 +316,7 @@ def create_bbox_augment(data_shape, rand_crop=0, rand_pad=0, rand_gray=0,
     """
     if inter_method == 10:
         inter_method = np.random.randint(0, 5)
-    augmenter = Sequential('default_bbox_aug_')
+    augmenter = Sequential()
     if rand_crop > 0:
         augmenter.add(bbox.ImageBboxRandomCropWithConstraints(
             p=rand_crop, min_scale=area_range[0], max_scale=1.0,
@@ -439,17 +439,17 @@ def __init__(self, batch_size, data_shape, path_imgrec=None, path_imglist=None,
             augmenter = create_bbox_augment(data_shape, **kwargs)
         elif isinstance(aug_list, list):
             if all([isinstance(a, HybridBlock) for a in aug_list]):
-                augmenter = HybridSequential('user_bbox_augment_')
+                augmenter = HybridSequential()
             else:
-                augmenter = Sequential('user_bbox_augment_')
+                augmenter = Sequential()
             for aug in aug_list:
                 augmenter.add(aug)
         elif isinstance(aug_list, Block):
             augmenter = aug_list
         else:
             raise ValueError('aug_list must be a list of Blocks')
         augmenter.hybridize()
-        wrapper_aug = Sequential('wrapper_bbox_aug_')
+        wrapper_aug = Sequential()
         wrapper_aug.add(BboxLabelTransform(coord_normalized))
         wrapper_aug.add(augmenter)
 

python/mxnet/gluon/contrib/estimator/estimator.py

@@ -71,7 +71,8 @@ class Estimator(object):
         the training net is given below:
 
         >>> net = _get_train_network()
-        >>> val_net = _get_test_network(params=net.collect_params())
+        >>> val_net = _get_test_network()
+        >>> val_net.share_parameters(net.collect_params())
         >>> net.initialize(ctx=ctx)
         >>> est = Estimator(net, loss, val_net=val_net)