in mmdnn/conversion/darknet/darknet_graph.py [0:0]
def build(self):
for i, block in enumerate(self.model):
# print("\n")
# print(i)
# print(block)
# continue
node = OrderedDict()
if block['type'] == 'net':
node['name'] = 'dk_Input'
node['input'] = ['data']
node['type'] = 'DataInput'
node['input_dim'] = ['-1']
# NHWC
node['input_dim'].append(block['height'])
node['input_dim'].append(block['width'])
node['input_dim'].append(block['channels'])
input_param = OrderedDict()
input_param['shape'] = self.dim_str_to_int(node['input_dim'])
input_param['_output_shape'] = self.dim_str_to_int(node['input_dim'])
node['attr'] = input_param
self.layer_map[node['name']] = DarknetGraphNode(node)
self.original_list[node['name']] = DarknetGraphNode(node)
self.layer_num_map[i] = node['name']
pre_node_name = node['name']
elif block['type'] == 'convolutional':
conv_layer = OrderedDict()
conv_layer['input'] = [pre_node_name]
input_shape = self.layer_map[pre_node_name].get_attr('_output_shape')
w = input_shape[1]
h = input_shape[2]
channels = input_shape[3]
# assert False
if 'name' in block.keys():
conv_layer['name'] = block['name']
else:
conv_layer['name'] = 'layer%d-conv' % i
conv_layer['type'] = 'Conv'
convolution_param = OrderedDict()
convolution_param['num_output'] = int(block['filters'])
convolution_param['kernel_size'] = int(block['size'])
convolution_param['kernel'] = [int(block['size']), int(block['size']), channels, int(block['filters'])]
convolution_param['pad'] = int(block['pad'])
if block['pad'] == '1':
convolution_param['padding'] = int(convolution_param['kernel_size'])//2
convolution_param['stride'] = int(block['stride'])
if block['batch_normalize'] == '1':
convolution_param['bias_term'] = 'false'
else:
convolution_param['bias_term'] = 'true'
output_w = self.conv_output_width(w ,convolution_param['padding'], convolution_param['kernel_size'], convolution_param['stride'])
output_h = self.conv_output_height(h ,convolution_param['padding'], convolution_param['kernel_size'], convolution_param['stride'])
convolution_param['_output_shape'] = [-1, output_w, output_h, convolution_param['num_output']]
conv_layer['attr'] = convolution_param
self.layer_map[conv_layer['name']] = DarknetGraphNode(conv_layer)
self.original_list[conv_layer['name']] = DarknetGraphNode(conv_layer)
pre_node_name = conv_layer['name']
if block['batch_normalize'] == '1':
bn_layer = OrderedDict()
bn_layer['input'] = [pre_node_name]
input_shape = self.layer_map[pre_node_name].get_attr('_output_shape')
if 'name' in block.keys():
bn_layer['name'] = '%s-bn' % block['name']
else:
bn_layer['name'] = 'layer%d-bn' % i
bn_layer['type'] = 'BatchNorm'
batch_norm_param = OrderedDict()
batch_norm_param['use_global_stats'] = True
batch_norm_param['_output_shape'] = convolution_param['_output_shape']
batch_norm_param['bias_term'] = True
batch_norm_param['scale'] = True
bn_layer['attr'] = batch_norm_param
self.layer_map[bn_layer['name']] = DarknetGraphNode(bn_layer)
self.original_list[bn_layer['name']] = DarknetGraphNode(bn_layer)
pre_node_name = bn_layer['name']
if block['activation'] != 'linear':
relu_layer = OrderedDict()
relu_layer['input'] = [pre_node_name]
if 'name' in block.keys():
relu_layer['name'] = '%s-act' % block['name']
else:
relu_layer['name'] = 'layer%d-act' % i
relu_layer['type'] = 'ReLU'
relu_param = OrderedDict()
if block['activation'] == 'leaky':
relu_layer['type'] = 'leakyReLU'
relu_param['negative_slope'] = '0.1'
relu_param['_output_shape'] = input_shape
relu_layer['attr'] = relu_param
self.layer_map[relu_layer['name']] = DarknetGraphNode(relu_layer)
self.layer_num_map[i] = relu_layer['name']
self.original_list[relu_layer['name']] = DarknetGraphNode(relu_layer)
pre_node_name = relu_layer['name']
else:
self.layer_num_map[i] = bn_layer['name']
elif block['type'] == 'maxpool':
max_layer = OrderedDict()
max_layer['input'] = [pre_node_name]
if 'name' in block.keys():
max_layer['name'] = block['name']
else:
max_layer['name'] = 'layer%d-maxpool' % i
max_layer['type'] = 'Pooling'
pooling_param = OrderedDict()
pooling_param['kernel_size'] = int(block['size'])
pooling_param['stride'] = int(block['stride'])
pooling_param['pool'] = 'MAX'
pooling_param['padding'] = 0
if 'pad' in block.keys() and int(block['pad']) == 1:
pooling_param['padding'] = (int(block['size'])-1)/2
input_shape = self.layer_map[pre_node_name].get_attr('_output_shape')
w = input_shape[1]
h = input_shape[2]
output_w = (w + 2*pooling_param['padding'])/pooling_param['stride']
output_h = (h + 2*pooling_param['padding'])/pooling_param['stride']
pooling_param['_output_shape'] = [-1, output_w, output_h, input_shape[-1]]
max_layer['attr'] = pooling_param
self.layer_map[max_layer['name']] = DarknetGraphNode(max_layer)
self.original_list[max_layer['name']] = DarknetGraphNode(max_layer)
self.layer_num_map[i] = max_layer['name']
pre_node_name = max_layer['name']
elif block['type'] == 'avgpool':
avg_layer = OrderedDict()
avg_layer['input'] = [pre_node_name]
if 'name' in block.keys():
avg_layer['name'] = block['name']
else:
avg_layer['name'] = 'layer%d-avgpool' % i
avg_layer['type'] = 'Pooling'
pooling_param = OrderedDict()
input_shape = self.layer_map[pre_node_name].get_attr('_output_shape')
pooling_param['_output_shape'] = [-1, 1, 1, input_shape[-1]]
pooling_param['pool'] = 'AVG'
avg_layer['attr'] = pooling_param
self.layer_map[avg_layer['name']] = DarknetGraphNode(avg_layer)
self.original_list[avg_layer['name']] = DarknetGraphNode(avg_layer)
self.layer_num_map[i] = avg_layer['name']
pre_node_name = avg_layer['name']
elif block['type'] == 'route':
prev = block['layers'].split(',') #[-1,61]
if len(prev) == 1:
prev_layer_id = i + int(prev[0])
self.layer_num_map[i] = self.layer_num_map[prev_layer_id]
pre_node_name = self.layer_num_map[i]
elif len(prev) == 2:
input_list = []
input_shape = []
route_layer = OrderedDict()
for p in prev:
if int(p)>0:
input_name = self.layer_num_map[int(p)+1]
input_list.append(input_name)
input_shape.append(self.layer_map[input_name].get_attr('_output_shape'))
else:
prev_layer_id = i + int(p)
input_name = self.layer_num_map[prev_layer_id]
input_shape.append(self.layer_map[input_name].get_attr('_output_shape'))
input_list.append(input_name)
route_param = OrderedDict()
shape_ = 0
for shape in input_shape:
shape_ += shape[-1]
route_param['axis'] = 3
route_param['_output_shape'] = input_shape[0][:-1] + [shape_]
route_layer['input'] = input_list
if 'name' in block.keys():
route_layer['name'] = block['name']
else:
route_layer['name'] = 'layer%d-concat' % i
route_layer['type'] = 'Concat'
route_layer['attr'] = route_param
self.layer_map[route_layer['name']] = DarknetGraphNode(route_layer)
self.original_list[route_layer['name']] = DarknetGraphNode(route_layer)
self.layer_num_map[i] = route_layer['name']
pre_node_name = route_layer['name']
elif block['type'] == 'shortcut':
prev_layer_id1 = i + int(block['from'])
prev_layer_id2 = i - 1
bottom1 = self.layer_num_map[prev_layer_id1]
bottom2 = self.layer_num_map[prev_layer_id2]
input_shape = self.layer_map[bottom2].get_attr('_output_shape')
shortcut_layer = OrderedDict()
shortcut_layer['input'] = [bottom1, bottom2]
# print(shortcut_layer['input'] )
if 'name' in block.keys():
shortcut_layer['name'] = block['name']
else:
shortcut_layer['name'] = 'layer%d-shortcut' % i
shortcut_layer['type'] = 'Add'
eltwise_param = OrderedDict()
eltwise_param['operation'] = 'SUM'
eltwise_param['_output_shape'] = input_shape
shortcut_layer['attr'] = eltwise_param
self.layer_map[shortcut_layer['name']] = DarknetGraphNode(shortcut_layer)
self.original_list[shortcut_layer['name']] = DarknetGraphNode(shortcut_layer)
self.layer_num_map[i] = shortcut_layer['name']
pre_node_name = shortcut_layer['name']
if block['activation'] != 'linear':
relu_layer = OrderedDict()
relu_layer['input'] = [pre_node_name]
if 'name' in block.keys():
relu_layer['name'] = '%s-act' % block['name']
else:
relu_layer['name'] = 'layer%d-act' % i
relu_layer['type'] = 'ReLU'
relu_param = OrderedDict()
relu_param['_output_shape'] = input_shape
if block['activation'] == 'leaky':
relu_param['negative_slope'] = '0.1'
relu_layer['attr'] = relu_param
self.layer_map[relu_layer['name']] = DarknetGraphNode(relu_layer)
self.original_list[relu_layer['name']] = DarknetGraphNode(relu_layer)
pre_node_name = relu_layer['name']
elif block['type'] == 'connected':
fc_layer = OrderedDict()
fc_layer['input'] = [pre_node_name]
if 'name' in block.keys():
fc_layer['name'] = block['name']
else:
fc_layer['name'] = 'layer%d-fc' % i
fc_layer['type'] = 'InnerProduct'
fc_param = OrderedDict()
fc_param['num_output'] = int(block['output'])
input_shape = self.layer_map[pre_node_name].get_attr('_output_shape')
fc_param['_output_shape'] = input_shape[:-1] + [fc_param['num_output']]
fc_layer['attr'] = fc_param
self.layer_map[fc_layer['name']] = DarknetGraphNode(fc_layer)
self.original_list[fc_layer['name']] = DarknetGraphNode(fc_layer)
self.layer_num_map[i] = fc_layer['name']
pre_node_name = fc_layer['name']
if block['activation'] != 'linear':
relu_layer = OrderedDict()
relu_layer['input'] = [pre_node_name]
if 'name' in block.keys():
relu_layer['name'] = '%s-act' % block['name']
else:
relu_layer['name'] = 'layer%d-act' % i
relu_layer['type'] = 'ReLU'
relu_param = OrderedDict()
if block['activation'] == 'leaky':
relu_param['negative_slope'] = '0.1'
relu_param['_output_shape'] = fc_param['_output_shape']
relu_layer['attr'] = relu_param
self.layer_map[relu_layer['name']] = DarknetGraphNode(relu_layer)
self.original_list[relu_layer['name']] = DarknetGraphNode(relu_layer)
pre_node_name = relu_layer['name']
elif block['type'] == 'softmax':
sm_layer = OrderedDict()
sm_layer['input'] = [pre_node_name]
if 'name' in block.keys():
sm_layer['name'] = block['name']
else:
sm_layer['name'] = 'layer%d-softmax' % i
sm_layer['type'] = 'Softmax'
softmax_param = OrderedDict()
input_shape = self.layer_map[pre_node_name].get_attr('_output_shape')
softmax_param['_output_shape'] = input_shape
sm_layer['attr'] = softmax_param
self.layer_map[sm_layer['name']] = DarknetGraphNode(sm_layer)
self.original_list[sm_layer['name']] = DarknetGraphNode(sm_layer)
self.layer_num_map[i] = sm_layer['name']
pre_node_name = sm_layer['name']
elif block['type'] == 'yolo':
yolo_layer = OrderedDict()
yolo_layer['input'] = [pre_node_name]
if 'name' in block.keys():
yolo_layer['name'] = block['name']
else:
yolo_layer['name'] = 'layer%d-yolo' % i
yolo_layer['type'] = 'yolo'
yolo_param = OrderedDict()
yolo_param['truth_thresh'] = float(block['truth_thresh'])
yolo_param['random'] = float(block['random'])
yolo_param['ignore_thresh'] = float(block['ignore_thresh'])
yolo_param['jitter'] = float(block['jitter'])
yolo_param['num'] = int(block['num'])
yolo_param['classes'] = int(block['classes'])
anchors = [int(t) for t in block['anchors'].split(',')]
yolo_param['anchors'] = anchors
mask = [int(t) for t in block['mask'].split(',')]
yolo_param['mask'] = mask
yolo_layer['attr'] = yolo_param
self.layer_map[yolo_layer['name']] = DarknetGraphNode(yolo_layer)
self.original_list[yolo_layer['name']] = DarknetGraphNode(yolo_layer)
self.layer_num_map[i] = yolo_layer['name']
elif block['type'] == 'upsample':
input_shape = self.layer_map[pre_node_name].get_attr('_output_shape')
upsample_layer = OrderedDict()
upsample_layer['input'] = [pre_node_name]
if 'name' in block.keys():
upsample_layer['name'] = block['name']
else:
upsample_layer['name'] = 'layer%d-upsample' % i
upsample_layer['type'] = 'upsample'
upsample_param = OrderedDict()
stride = block['stride']
upsample_param['scales'] = [int(stride), int(stride)]
upsample_param['_output_shape'] = [input_shape[0]] + [q*int(stride) for q in input_shape[1:3]] + [input_shape[-1]]
upsample_layer['attr'] = upsample_param
self.layer_map[upsample_layer['name']] = DarknetGraphNode(upsample_layer)
self.original_list[upsample_layer['name']] = DarknetGraphNode(upsample_layer)
self.layer_num_map[i] = upsample_layer['name']
pre_node_name = upsample_layer['name']
elif block['type'] == 'cost':
continue
# spacetodepth
elif block['type'] == 'reorg':
input_shape = self.layer_map[pre_node_name].get_attr('_output_shape')
reorg_layer = OrderedDict()
reorg_layer['input'] = [pre_node_name]
if 'name' in block.keys():
reorg_layer['name'] = block['name']
else:
reorg_layer['name'] = 'layer%d-reorg' % i
reorg_layer['type'] = 'SpaceToDepth'
reorg_param = OrderedDict()
stride = int(block['stride'])
reorg_param['strides'] = stride
reorg_param['_output_shape'] = [-1, input_shape[1]/stride, input_shape[2]/stride, input_shape[3]*stride*stride]
reorg_layer['attr'] = reorg_param
self.layer_map[reorg_layer['name']] = DarknetGraphNode(reorg_layer)
self.original_list[reorg_layer['name']] = DarknetGraphNode(reorg_layer)
self.layer_num_map[i] = reorg_layer['name']
pre_node_name = reorg_layer['name']
elif block['type'] == 'region':
# print(block)
region_layer = OrderedDict()
region_layer['input'] = [pre_node_name]
if 'name' in block.keys():
region_layer['name'] = block['name']
else:
region_layer['name'] = 'layer%d-region' % i
region_layer['type'] = 'region'
region_param = OrderedDict()
region_param['softmax'] = int(block['softmax'])
region_param['thresh'] = float(block['thresh'])
region_param['random'] = float(block['random'])
region_param['jitter'] = float(block['jitter'])
region_param['num'] = int(block['num'])
region_param['classes'] = int(block['classes'])
region_param['coords'] = int(block['coords'])
region_param['rescore'] = int(block['rescore'])
region_param['object_scale'] = int(block['object_scale'])
region_param['noobject_scale'] = int(block['noobject_scale'])
region_param['class_scale'] = int(block['class_scale'])
region_param['coord_scale'] = int(block['coord_scale'])
region_param['bias_match'] = int(block['bias_match'])
region_param['absolute'] = int(block['absolute'])
anchors = [float(t) for t in block['anchors'].split(',')]
region_param['anchors'] = anchors
region_layer['attr'] = region_param
# print(region_layer)
self.layer_map[region_layer['name']] = DarknetGraphNode(region_layer)
self.original_list[region_layer['name']] = DarknetGraphNode(region_layer)
self.layer_num_map[i] = region_layer['name']
# assert False
else:
print('unknown layer type %s ' % block['type'])
print(block,"\n")
assert False
for layer in self.layer_map:
for pred in self.layer_map[layer].layer['input']:
if pred not in self.layer_map.keys() and pred != 'data':
print(pred)
print("::::::::::::: unknown input :::::::::::::")
assert False
self._make_connection(pred, layer)
super(DarknetGraph, self).build()