def get_cnn_layer_label_mismatch_penalties(non_assignment_penalty, max_conv_size=7,
conv_scale=None):
""" Gets the label mismatch matrix for a CNN. """
conv_scale = np.sqrt(2)/10.0 if conv_scale is None else conv_scale
cnn_layer_labels = neural_network.get_cnn_layer_labels(max_conv_size)
num_labels = len(cnn_layer_labels)
label_penalties = np.zeros((num_labels, num_labels))
for i in range(num_labels):
for j in range(i, num_labels):
labi = cnn_layer_labels[i]
labj = cnn_layer_labels[j]
if labi == labj:
cost = 0.0
elif (labi.startswith('conv') and labj.startswith('conv')) or \
(labi.startswith('res') and labj.startswith('res')):
cost = _get_conv_filter_size_cost(labi, labj, conv_scale)
elif (labi.startswith('conv') and labj.startswith('res')) or \
(labi.startswith('res') and labj.startswith('conv')):
raw_cost = _get_conv_filter_size_cost(labi, labj, conv_scale)
cost = raw_cost if raw_cost > non_assignment_penalty else \
(CONV_RES_RAW_COST_FRAC * raw_cost +
(1-CONV_RES_RAW_COST_FRAC) * non_assignment_penalty)
# When mapping the a convolutional block to a residual block, set the cost
# to be in-between the cost for a conv-conv layer and the non_assignment_penalty.
elif labi.endswith('pool') and labj.endswith('pool'):
cost = 0.5
else:
cost = np.inf
label_penalties[i, j] = cost * non_assignment_penalty
label_penalties[j, i] = cost * non_assignment_penalty
return cnn_layer_labels, label_penalties
def get_vgg_net(num_conv_layers_per_block=4, cnn_layer_labels=None):
""" Returns a VGG net. """
cnn_layer_labels = cnn_layer_labels if cnn_layer_labels is not None else \
get_cnn_layer_labels()
layer_labels = [
'ip', 'conv3', 'conv3', 'max-pool', 'conv3', 'conv3', 'max-pool'
]
num_filters_each_layer = [None, 64, 64, None, 128, 128, None]
# Now create the blocks
block_filter_sizes = [128, 256, 512]
for bfs in block_filter_sizes:
layer_labels.extend(
['conv3' for _ in range(num_conv_layers_per_block)] + ['max-pool'])
num_filters_each_layer.extend([bfs] * num_conv_layers_per_block +
[None])
layer_labels.extend(['fc', 'fc', 'fc', 'softmax', 'op'])
num_filters_each_layer.extend([128, 256, 512, None, None])
num_layers = len(layer_labels)
# Construct the connectivity matrix
conn_mat = get_feedforward_adj_mat(num_layers)
strides = [(1 if is_a_conv_layer_label(ll) else None)
for ll in layer_labels]
vgg = ConvNeuralNetwork(layer_labels, conn_mat, num_filters_each_layer,
strides, cnn_layer_labels)
return vgg
def get_vgg_net(num_conv_layers_per_block=2, cnn_layer_labels=None):
""" Returns a VGG net. """
cnn_layer_labels = cnn_layer_labels if cnn_layer_labels is not None else \
get_cnn_layer_labels()
#print("cnn_layer_labels:",cnn_layer_labels)
layer_labels = [
'ip', 'conv3', 'conv3', 'avg-pool', 'conv3', 'conv3', 'avg-pool'
]
num_filters_each_layer = [None, 64, 64, None, 128, 128, None]
# Now create the blocks
block_filter_sizes = [256, 512]
for bfs in block_filter_sizes:
layer_labels.extend(
['conv3' for _ in range(num_conv_layers_per_block)] + ['avg-pool'])
num_filters_each_layer.extend([bfs] * num_conv_layers_per_block +
[None])
layer_labels.extend(['fc', 'softmax', 'op'])
num_filters_each_layer.extend([512, None, None])
#print("layer_labels",layer_labels)
#print("number_of_lyers",len(layer_labels))
#print("num_filters_each_layer",num_filters_each_layer)
num_layers = len(layer_labels)
# Construct the connectivity matrix
conn_mat = get_feedforward_adj_mat(num_layers)
strides = [(1 if is_a_conv_layer_label(ll) else None)
for ll in layer_labels]
vgg = ConvNeuralNetwork(layer_labels, conn_mat, num_filters_each_layer,
strides, cnn_layer_labels)
#print("strides:",strides)
#print("layer_parents:",vgg.conn_mat.viewkeys())
return vgg
def test_get_labels(self):
""" Tests labels generated for a CNN and MLP. """
self.report('Testing the labels for CNN and MLP.')
cnn_true_labels_7 = sorted([
'ip', 'op', 'fc', 'max-pool', 'avg-pool', 'softmax', 'res3',
'res5', 'res7', 'conv3', 'conv5', 'conv7'
])
cnn_true_labels_3 = sorted([
'ip', 'op', 'fc', 'max-pool', 'avg-pool', 'softmax', 'res3',
'conv3'
])
mlp_true_labels = sorted(['ip', 'op', 'relu', 'linear'])
cnn_ret_labels_7 = sorted(neural_network.get_cnn_layer_labels(7))
cnn_ret_labels_3 = sorted(neural_network.get_cnn_layer_labels(3))
mlp_ret_labels = sorted(
neural_network.get_mlp_layer_labels('reg', ['relu']))
assert cnn_true_labels_7 == cnn_ret_labels_7
assert cnn_true_labels_3 == cnn_ret_labels_3
assert mlp_true_labels == mlp_ret_labels
def _get_multidepth_cnn_eg12_common():
""" A network with 2 softmax layers mostly for debugging common operations. """
cnn_layer_labels = get_cnn_layer_labels()
layer_labels = [
'ip', 'op', 'softmax', 'fc', 'softmax', 'fc', 'conv5', 'avg-pool',
'max-pool', 'conv3', 'conv3', 'max-pool', 'max-pool', 'conv3', 'conv7'
]
num_filters_each_layer = [
None, None, None, 64, None, 64, 128, None, None, 64, 64, None, None,
128, 64
]
edges = [(0, 14), (14, 6), (14, 9), (14, 10), (6, 7), (7, 3), (3, 2),
(2, 1), (9, 8), (8, 5), (5, 4), (4, 1), (10, 11), (11, 13),
(13, 12), (12, 5)]
strides = [(1 if is_a_conv_layer_label(ll) else None)
for ll in layer_labels]
return layer_labels, edges, num_filters_each_layer, cnn_layer_labels, strides
def _get_blocked_cnn_params(num_blocks,
num_layers_per_block,
block_layer_type,
num_fc_layers,
num_conv_filters_in_layers=None,
num_fc_nodes_in_layers=None,
cnn_layer_labels=None):
""" Returns parameters for a blocked CNN.
num_blocks: # blocks, i.e. the number of repeated convolutional layers.
num_layers_per_block: # layers per block.
num_fc_layers: # fully connected layers.
num_conv_filters_in_layers: # filters in the layers for each block.
num_fc_nodes_in_layers: sizes of the fc layers.
cnn_layer_labels: Labels for all layer types in a CNN.
"""
layer_labels = ['ip', 'conv7', 'max-pool']
num_filters_each_layer = [None, 64, None]
strides = [None, 1, None]
num_conv_filters_in_layers = num_conv_filters_in_layers if num_conv_filters_in_layers \
is not None else _dflt_unit_sizes(num_blocks)
num_fc_nodes_in_layers = num_fc_nodes_in_layers if num_fc_nodes_in_layers is not None \
else [2 * num_conv_filters_in_layers[-1]] * num_fc_layers
cnn_layer_labels = cnn_layer_labels if cnn_layer_labels is not None else \
get_cnn_layer_labels()
# Construct blocks
for block_idx in range(num_blocks):
layer_labels.extend(
[block_layer_type for _ in range(num_layers_per_block)])
num_filters_each_layer.extend([num_conv_filters_in_layers[block_idx]] *
num_layers_per_block)
strides.extend([2] + [1] * (num_layers_per_block - 1))
# Pooling layer after the blocks
layer_labels.append('avg-pool')
num_filters_each_layer.append(None)
strides.append(None)
# Add FC layers
layer_labels.extend(['fc'
for _ in range(num_fc_layers)] + ['softmax', 'op'])
num_filters_each_layer.extend(num_fc_nodes_in_layers + [None, None])
strides.extend([None] * (num_fc_layers + 2))
# Construct the connectivity matrix
num_layers = len(layer_labels)
conn_mat = get_feedforward_adj_mat(num_layers)
return layer_labels, conn_mat, num_filters_each_layer, cnn_layer_labels, strides
def get_vgg_net_chen(num_conv_layers_per_block=3, cnn_layer_labels=None):
cnn_layer_labels = cnn_layer_labels if cnn_layer_labels is not None else \
get_cnn_layer_labels()
layer_labels = [
'ip', 'conv3', 'conv3', 'max-pool', 'conv3', 'conv3', 'max-pool'
]
num_filters_each_layer = [None, 64, 64, None, 128, 128, None]
#now create the blocks
block_filter_sizes = [256, 512, 512]
for bfs in block_filter_sizes:
layer_labels.extend(
['conv3' for _ in range(num_conv_layers_per_block)] + ['max-pool'])
num_filters_each_layer.extend([bfs] * num_conv_layers_per_block +
[None])
layer_labels.extend(['fc', 'fc', 'fc', 'softmax', 'op'])
num_filters_each_layer.extend([4096, 4096, 1000, None, None])
num_layers = len(layer_labels)
conn_mat = get_feedforward_adj_mat(num_layers)
strides = []
for ll in layer_labels:
if is_a_conv_layer_label(ll):
strides.extend([1])
elif is_a_pooling_layer_label(ll):
strides.extend([2])
else:
strides.extend([None])
#print("layer_labels:",layer_labels)
#print("strides:",strides)
#print("num_filters_each_layer:",num_filters_each_layer)
vgg_16_chen = ConvNeuralNetwork(layer_labels,conn_mat,num_filters_each_layer,strides,\
cnn_layer_labels)
#print("layer_parents:",vgg_16_chen.conn_mat.viewkeys())
return vgg_16_chen
def generate_cnn_architectures():
# pylint: disable=bad-whitespace
""" Generates 4 neural networks. """
all_layer_label_classes = get_cnn_layer_labels()
# Network 1
layer_labels = [
'ip', 'op', 'conv3', 'fc', 'conv3', 'conv3', 'conv3', 'softmax',
'max-pool'
]
num_filters_each_layer = [None, None, 32, 16, 16, 8, 8, None, None]
A = get_dok_mat_with_set_coords(9, [(0, 4), (3, 7), (4, 5), (4, 6), (5, 2),
(6, 2), (7, 1), (2, 8), (8, 3)])
strides = [
None if ll in ['ip', 'op', 'fc', 'softmax', 'max-pool'] else 1
for ll in layer_labels
]
cnn_1 = ConvNeuralNetwork(layer_labels, A, num_filters_each_layer, strides,
all_layer_label_classes)
# Network 2
layer_labels = [
'ip', 'conv3', 'conv3', 'conv3', 'fc', 'softmax', 'op', 'max-pool'
]
num_filters_each_layer = [None, 16, 16, 32, 16, None, None, None]
A = get_dok_mat_with_set_coords(8, [(0, 1), (1, 2), (2, 3), (4, 5), (5, 6),
(3, 7), (7, 4)])
strides = [
None if ll in ['ip', 'op', 'fc', 'softmax', 'max-pool'] else 1
for ll in layer_labels
]
cnn_2 = ConvNeuralNetwork(layer_labels, A, num_filters_each_layer, strides,
all_layer_label_classes)
# Network 3
layer_labels = [
'ip', 'conv3', 'conv3', 'conv5', 'conv3', 'max-pool', 'fc', 'softmax',
'op'
]
num_filters_each_layer = [None, 16, 16, 16, 32, None, 32, None, None]
A = get_dok_mat_with_set_coords(9, [(0, 1), (1, 2), (1, 3), (1, 4), (2, 5),
(3, 5), (4, 6), (5, 6), (6, 7),
(7, 8)])
strides = [
None if ll in ['ip', 'op', 'fc', 'softmax', 'max-pool'] else 1
for ll in layer_labels
]
strides[4] = 2
cnn_3 = ConvNeuralNetwork(layer_labels, A, num_filters_each_layer, strides,
all_layer_label_classes)
# Network 4
layer_labels = [
'ip', 'conv3', 'conv3', 'conv5', 'conv3', 'avg-pool', 'conv5', 'fc',
'softmax', 'op'
]
num_filters_each_layer = [None, 16, 16, 16, 32, None, 32, 32, None, None]
A = get_dok_mat_with_set_coords(10,
[(0, 1), (1, 2), (1, 3), (1, 4), (2, 5),
(3, 5), (4, 6), (5, 7), (6, 7), (7, 8),
(8, 9)])
strides = [
None
if ll in ['ip', 'op', 'fc', 'softmax', 'max-pool', 'avg-pool'] else 1
for ll in layer_labels
]
strides[4] = 2
cnn_4 = ConvNeuralNetwork(layer_labels, A, num_filters_each_layer, strides,
all_layer_label_classes)
# Network 5
layer_labels = [
'ip', 'conv3', 'conv3', 'conv5', 'conv5', 'avg-pool', 'fc', 'softmax',
'op', 'conv3'
]
num_filters_each_layer = [None, 16, 16, 16, 32, None, 32, None, None, 16]
A = get_dok_mat_with_set_coords(10,
[(0, 1), (1, 2), (1, 3), (2, 5), (3, 5),
(4, 6), (5, 6), (6, 7), (7, 8), (0, 9),
(9, 4)])
strides = [
None if ll in ['ip', 'op', 'fc', 'softmax', 'avg-pool'] else 1
for ll in layer_labels
]
strides[4] = 2
cnn_5 = ConvNeuralNetwork(layer_labels, A, num_filters_each_layer, strides,
all_layer_label_classes)
# Network 6
layer_labels = [
'ip', 'conv3', 'conv3', 'conv3', 'fc', 'fc', 'op', 'max-pool', 'fc',
'softmax'
]
num_filters_each_layer = [None, 16, 16, 32, 32, 32, None, None, 32, None]
A = get_dok_mat_with_set_coords(10,
[(0, 1), (1, 2), (2, 3), (4, 5), (5, 9),
(3, 7), (7, 4), (4, 8), (8, 9), (9, 6)])
strides = [
None if ll in ['ip', 'op', 'fc', 'softmax', 'max-pool'] else 1
for ll in layer_labels
]
cnn_6 = ConvNeuralNetwork(layer_labels, A, num_filters_each_layer, strides,
all_layer_label_classes)
# Network 7 - Two softmax layers both pointing to output
layer_labels = [
'ip', 'conv3', 'conv3', 'conv3', 'fc', 'fc', 'op', 'max-pool', 'fc',
'softmax', 'softmax'
]
num_filters_each_layer = [
None, 16, 16, 32, 32, 32, None, None, 32, None, None
]
A = get_dok_mat_with_set_coords(11,
[(0, 1), (1, 2), (2, 3), (4, 5), (5, 9),
(3, 7), (7, 4), (4, 8), (8, 9), (9, 6),
(8, 10), (10, 6)])
strides = [
None if ll in ['ip', 'op', 'fc', 'softmax', 'max-pool'] else 1
for ll in layer_labels
]
cnn_7 = ConvNeuralNetwork(layer_labels, A, num_filters_each_layer, strides,
all_layer_label_classes)
# Network 8 - Similar to previous, except with residual layers
layer_labels = [
'ip', 'conv3', 'res3', 'res5', 'fc', 'fc', 'op', 'max-pool', 'fc',
'softmax', 'softmax'
]
num_filters_each_layer = [
None, 16, 16, 32, 32, 32, None, None, 32, None, None
]
A = get_dok_mat_with_set_coords(11,
[(0, 1), (1, 2), (2, 3), (4, 5), (5, 9),
(3, 7), (7, 4), (4, 8), (8, 9), (9, 6),
(8, 10), (10, 6)])
strides = [
None if ll in ['ip', 'op', 'fc', 'softmax', 'max-pool'] else 1
for ll in layer_labels
]
cnn_8 = ConvNeuralNetwork(layer_labels, A, num_filters_each_layer, strides,
all_layer_label_classes)
# Network 9 - Similar to previous, except decreasing units for residual layers
layer_labels = [
'ip', 'conv3', 'res3', 'res5', 'res7', 'fc', 'op', 'max-pool', 'fc',
'softmax', 'softmax'
]
num_filters_each_layer = [
None, 16, 32, 8, 32, 128, None, None, 256, None, None
]
A = get_dok_mat_with_set_coords(11,
[(0, 1), (1, 2), (2, 3), (4, 5), (5, 9),
(3, 7), (7, 4), (4, 8), (8, 9), (9, 6),
(8, 10), (10, 6)])
strides = [
None if ll in ['ip', 'op', 'fc', 'softmax', 'max-pool'] else 1
for ll in layer_labels
]
cnn_9 = ConvNeuralNetwork(layer_labels, A, num_filters_each_layer, strides,
all_layer_label_classes)
return [
cnn_1,
cnn_2,
cnn_3,
cnn_4,
cnn_5,
cnn_6,
cnn_7,
cnn_8,
cnn_9,
get_vgg_net(2),
get_blocked_cnn(3, 4, 1),
get_resnet_cnn(3, 2, 1),
get_multidepth_cnn_eg1(),
get_multidepth_cnn_eg2(),
]
