add group_conv. can run, but very sloooooow

util/cfg_layer.py

@@ -34,7 +34,7 @@ def cfg_net(B, H, W, C, net, param, weights_walker, stack, output_index, scope,
     return net
 
 
-def cfg_convolutional(B, H, W, C, net, param, weights_walker, stack, output_index, scope, training, const_inits, verbose):
+def cfg_group_convolutional(B, H, W, C, net, param, weights_walker, stack, output_index, scope, training, const_inits, verbose):
     batch_normalize = 'batch_normalize' in param
     size = int(param['size'])
     filters = int(param['filters'])
@@ -54,6 +54,94 @@ def cfg_convolutional(B, H, W, C, net, param, weights_walker, stack, output_inde
                                   batch_normalize=batch_normalize)
     weights = weights.reshape(filters, int(C/groups), size, size).transpose([2, 3, 1, 0])
 
+    channels_per_group = int(C/groups)
+    channels_cnt_list = [channels_per_group for i in range(groups)]
+    sub_net_list = tf.split(net,num_or_size_splits = channels_cnt_list,axis= 3)
+
+    filters_per_group = int(filters/groups)
+    filters_cnt_list = [filters_per_group for i in range(groups)]
+    sub_weight_list = tf.split(weights,num_or_size_splits = filters_cnt_list,axis= 3)
+    sub_biases_list = tf.split(biases,num_or_size_splits = filters_cnt_list,axis= 0)
+    for group_index in range(groups):
+        conv_args = {
+            "filters": filters_per_group,
+            "kernel_size": size,
+            "strides": stride,
+            "activation": None,
+            "padding": pad,
+        }
+        if group_index > 0 :
+            conv_args.update({
+                "reuse":True
+            })
+        if const_inits:
+            conv_args.update({
+                "kernel_initializer": tf.initializers.constant(sub_weight_list[group_index].eval(session=tf.Session()), verify_shape=True),
+                "bias_initializer": tf.initializers.constant(sub_biases_list[group_index].eval(session=tf.Session()), verify_shape=True)
+            })
+
+        if batch_normalize:
+            conv_args.update({
+                "use_bias": False
+            })
+        net_sub_result = tf.layers.conv2d(sub_net_list[group_index], name=scope, **conv_args)
+        if group_index == 0:
+            net_output = net_sub_result
+        else:
+            net_output = tf.concat([net_sub_result,net_output],3)
+
+    net = net_output
+    #print(net)
+
+    if batch_normalize:
+        batch_norm_args = {
+            "momentum": _BATCH_NORM_MOMENTUM,
+            "epsilon": _BATCH_NORM_EPSILON,
+            "fused": True,
+            "trainable": training,
+            "training": training
+        }
+
+        if const_inits:
+            batch_norm_args.update({
+                "beta_initializer": tf.initializers.constant(biases, verify_shape=True),
+                "gamma_initializer": tf.initializers.constant(scales, verify_shape=True),
+                "moving_mean_initializer": tf.initializers.constant(rolling_mean, verify_shape=True),
+                "moving_variance_initializer": tf.initializers.constant(rolling_variance, verify_shape=True)
+            })
+
+        net = tf.layers.batch_normalization(net, name=scope+'/BatchNorm', **batch_norm_args)
+
+    if activation:
+        net = activation(net, scope+'/Activation')
+
+    return net
+
+
+
+def cfg_convolutional(B, H, W, C, net, param, weights_walker, stack, output_index, scope, training, const_inits, verbose):
+    groups = int(param.get('groups',1))
+    if groups > 1:
+        return cfg_group_convolutional(B, H, W, C, net, param, weights_walker, stack, output_index, scope, training, const_inits, verbose)
+    del groups
+
+    batch_normalize = 'batch_normalize' in param
+    size = int(param['size'])
+    filters = int(param['filters'])
+    stride = int(param['stride'])
+    pad = 'same' if param['pad'] == '1' else 'valid'
+    activation = None
+    weight_size = C * filters * size * size
+    if "activation" in param:
+        activation = _activation_dict.get(param['activation'], None)
+
+    biases, scales, rolling_mean, rolling_variance, weights = \
+        weights_walker.get_weight(param['name'],
+                                  filters=filters,
+                                  weight_size=weight_size,
+                                  batch_normalize=batch_normalize)
+    weights = weights.reshape(filters, C, size, size).transpose([2, 3, 1, 0])
+
     conv_args = {
         "filters": filters,
         "kernel_size": size,
@@ -101,8 +189,8 @@ def cfg_convolutional(B, H, W, C, net, param, weights_walker, stack, output_inde
 
 
 def cfg_dropout(B, H, W, C, net, param, weights_walker, stack, output_index, scope, training, const_inits, verbose):
-
-    net = tf.layers.dropout(net,rate=param['probability'],  training=training)
+    if training:
+        net = tf.layers.dropout(net,rate=param['probability'],  training=training)
     return net