def deeper_conv_block(conv_layer, kernel_size, weighted=True):
filter_shape = (kernel_size, ) * 2
n_filters = conv_layer.filters
weight = np.zeros(filter_shape + (n_filters, n_filters))
center = tuple(map(lambda x: int((x - 1) / 2), filter_shape))
for i in range(n_filters):
filter_weight = np.zeros(filter_shape + (n_filters, ))
index = center + (i, )
filter_weight[index] = 1
weight[..., i] = filter_weight
bias = np.zeros(n_filters)
new_conv_layer = StubConv(n_filters,
kernel_size=filter_shape,
func=conv_layer.func)
bn = StubBatchNormalization()
if weighted:
new_conv_layer.set_weights(
(add_noise(weight,
np.array([0, 1])), add_noise(bias, np.array([0, 1]))))
new_weights = [
np.ones(n_filters, dtype=np.float32),
np.zeros(n_filters, dtype=np.float32),
np.zeros(n_filters, dtype=np.float32),
np.ones(n_filters, dtype=np.float32)
]
bn.set_weights(new_weights)
return [
StubActivation('relu'), new_conv_layer, bn,
StubDropout(constant.CONV_DROPOUT_RATE)
]
def deeper_conv_block(conv_layer, kernel_size, weighted=True):
filter_shape = (kernel_size, ) * 2
n_filters = conv_layer.filters
weight = np.zeros((n_filters, n_filters) + filter_shape)
center = tuple(map(lambda x: int((x - 1) / 2), filter_shape))
for i in range(n_filters):
filter_weight = np.zeros((n_filters, ) + filter_shape)
index = (i, ) + center
filter_weight[index] = 1
weight[i, ...] = filter_weight
bias = np.zeros(n_filters)
new_conv_layer = StubConv(conv_layer.filters,
n_filters,
kernel_size=kernel_size)
bn = StubBatchNormalization(n_filters)
if weighted:
new_conv_layer.set_weights(
(add_noise(weight,
np.array([0, 1])), add_noise(bias, np.array([0, 1]))))
new_weights = [
add_noise(np.ones(n_filters, dtype=np.float32), np.array([0, 1])),
add_noise(np.zeros(n_filters, dtype=np.float32), np.array([0, 1])),
add_noise(np.zeros(n_filters, dtype=np.float32), np.array([0, 1])),
add_noise(np.ones(n_filters, dtype=np.float32), np.array([0, 1]))
]
bn.set_weights(new_weights)
return [StubReLU(), new_conv_layer, bn]
def wider_bn(layer, start_dim, total_dim, n_add, weighted=True):
"""Get new layer with wider batch normalization for current layer
Args:
weighted:
layer: the layer from which we get new layer with wider batch normalization
start_dim: the started dimension
total_dim: the total dimension
n_add: the output shape
Returns:
The new layer with wider batch normalization
"""
if not weighted:
return StubBatchNormalization()
weights = layer.get_weights()
new_weights = [
np.ones(n_add, dtype=np.float32),
np.zeros(n_add, dtype=np.float32),
np.zeros(n_add, dtype=np.float32),
np.ones(n_add, dtype=np.float32)
]
student_w = tuple()
for weight, new_weight in zip(weights, new_weights):
temp_w = weight.copy()
temp_w = np.concatenate(
(temp_w[:start_dim], new_weight, temp_w[start_dim:total_dim]))
student_w += (temp_w, )
new_layer = StubBatchNormalization()
new_layer.set_weights(student_w)
return new_layer
def deeper_conv_block(conv_layer, kernel_size, weighted=True):
filter_shape = (kernel_size,) * 2
n_filters = conv_layer.filters
weight = np.zeros((n_filters, n_filters) + filter_shape)
center = tuple(map(lambda x: int((x - 1) / 2), filter_shape))
for i in range(n_filters):
filter_weight = np.zeros((n_filters,) + filter_shape)
index = (i,) + center
filter_weight[index] = 1
weight[i, ...] = filter_weight
bias = np.zeros(n_filters)
new_conv_layer = StubConv(conv_layer.filters, n_filters, kernel_size=kernel_size)
bn = StubBatchNormalization(n_filters)
if weighted:
new_conv_layer.set_weights((add_noise(weight, np.array([0, 1])), add_noise(bias, np.array([0, 1]))))
new_weights = [add_noise(np.ones(n_filters, dtype=np.float32), np.array([0, 1])),
add_noise(np.zeros(n_filters, dtype=np.float32), np.array([0, 1])),
add_noise(np.zeros(n_filters, dtype=np.float32), np.array([0, 1])),
add_noise(np.ones(n_filters, dtype=np.float32), np.array([0, 1]))]
bn.set_weights(new_weights)
return [StubReLU(),
new_conv_layer,
bn]
def get_conv_dense_model():
graph = Graph((32, 32, 3), False)
output_node_id = 0
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(StubConv(3, 3, 3), output_node_id)
output_node_id = graph.add_layer(StubBatchNormalization(3), output_node_id)
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(StubConv(3, 3, 3), output_node_id)
output_node_id = graph.add_layer(StubBatchNormalization(3), output_node_id)
output_node_id = graph.add_layer(StubFlatten(), output_node_id)
output_node_id = graph.add_layer(StubDropout(Constant.DENSE_DROPOUT_RATE), output_node_id)
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(StubDense(graph.node_list[output_node_id].shape[0], 5),
output_node_id)
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(StubDense(5, 5), output_node_id)
graph.add_layer(StubSoftmax(), output_node_id)
graph.produce_model().set_weight_to_graph()
return graph
def get_add_skip_model():
graph = Graph((5, 5, 3), False)
output_node_id = 0
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(StubConv(3, 3, 3), output_node_id)
output_node_id = graph.add_layer(StubBatchNormalization(3), output_node_id)
output_node_id = graph.add_layer(StubDropout(constant.CONV_DROPOUT_RATE), output_node_id)
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(StubConv(3, 3, 3), output_node_id)
output_node_id = graph.add_layer(StubBatchNormalization(3), output_node_id)
output_node_id = graph.add_layer(StubDropout(constant.CONV_DROPOUT_RATE), output_node_id)
temp_node_id = output_node_id
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(StubConv(3, 3, 3), output_node_id)
output_node_id = graph.add_layer(StubBatchNormalization(3), output_node_id)
output_node_id = graph.add_layer(StubDropout(constant.CONV_DROPOUT_RATE), output_node_id)
temp_node_id = graph.add_layer(StubConv(3, 3, 1), temp_node_id)
output_node_id = graph.add_layer(StubAdd(), [output_node_id, temp_node_id])
temp_node_id = output_node_id
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(StubConv(3, 3, 3), output_node_id)
output_node_id = graph.add_layer(StubBatchNormalization(3), output_node_id)
output_node_id = graph.add_layer(StubDropout(constant.CONV_DROPOUT_RATE), output_node_id)
temp_node_id = graph.add_layer(StubConv(3, 3, 1), temp_node_id)
output_node_id = graph.add_layer(StubAdd(), [output_node_id, temp_node_id])
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(StubConv(3, 3, 3), output_node_id)
output_node_id = graph.add_layer(StubBatchNormalization(3), output_node_id)
output_node_id = graph.add_layer(StubDropout(constant.CONV_DROPOUT_RATE), output_node_id)
output_node_id = graph.add_layer(StubFlatten(), output_node_id)
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(StubDense(graph.node_list[output_node_id].shape[0], 5),
output_node_id)
output_node_id = graph.add_layer(StubDropout(constant.DENSE_DROPOUT_RATE), output_node_id)
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(StubDense(5, 5), output_node_id)
output_node_id = graph.add_layer(StubDropout(constant.DENSE_DROPOUT_RATE), output_node_id)
graph.add_layer(StubSoftmax(), output_node_id)
graph.produce_model().set_weight_to_graph()
return graph
def to_add_skip_model(self, start_id, end_id):
"""Add a weighted add skip-connection from after start node to end node.
Args:
start_id: The convolutional layer ID, after which to start the skip-connection.
end_id: The convolutional layer ID, after which to end the skip-connection.
"""
self.operation_history.append(('to_add_skip_model', start_id, end_id))
conv_block_input_id = self._conv_block_end_node(start_id)
conv_block_input_id = self.adj_list[conv_block_input_id][0][0]
block_last_layer_input_id = self._conv_block_end_node(end_id)
# Add the pooling layer chain.
layer_list = self._get_pooling_layers(conv_block_input_id, block_last_layer_input_id)
skip_output_id = conv_block_input_id
for index, layer_id in enumerate(layer_list):
skip_output_id = self.add_layer(deepcopy(self.layer_list[layer_id]), skip_output_id)
# Add the conv layer
new_relu_layer = StubReLU()
skip_output_id = self.add_layer(new_relu_layer, skip_output_id)
new_conv_layer = StubConv(self.layer_list[start_id].filters, self.layer_list[end_id].filters, 1)
skip_output_id = self.add_layer(new_conv_layer, skip_output_id)
new_bn_layer = StubBatchNormalization(self.layer_list[end_id].filters)
skip_output_id = self.add_layer(new_bn_layer, skip_output_id)
# Add the add layer.
block_last_layer_output_id = self.adj_list[block_last_layer_input_id][0][0]
add_input_node_id = self._add_node(deepcopy(self.node_list[block_last_layer_output_id]))
add_layer = StubAdd()
self._redirect_edge(block_last_layer_input_id, block_last_layer_output_id, add_input_node_id)
self._add_edge(add_layer, add_input_node_id, block_last_layer_output_id)
self._add_edge(add_layer, skip_output_id, block_last_layer_output_id)
add_layer.input = [self.node_list[add_input_node_id], self.node_list[skip_output_id]]
add_layer.output = self.node_list[block_last_layer_output_id]
self.node_list[block_last_layer_output_id].shape = add_layer.output_shape
# Set weights to the additional conv layer.
if self.weighted:
filters_end = self.layer_list[end_id].filters
filters_start = self.layer_list[start_id].filters
filter_shape = (1,) * (len(self.layer_list[end_id].get_weights()[0].shape) - 2)
weights = np.zeros((filters_end, filters_start) + filter_shape)
bias = np.zeros(filters_end)
new_conv_layer.set_weights((add_noise(weights, np.array([0, 1])), add_noise(bias, np.array([0, 1]))))
n_filters = filters_end
new_weights = [add_noise(np.ones(n_filters, dtype=np.float32), np.array([0, 1])),
add_noise(np.zeros(n_filters, dtype=np.float32), np.array([0, 1])),
add_noise(np.zeros(n_filters, dtype=np.float32), np.array([0, 1])),
add_noise(np.ones(n_filters, dtype=np.float32), np.array([0, 1]))]
new_bn_layer.set_weights(new_weights)
def generate(self,
model_len=constant.MODEL_LEN,
model_width=constant.MODEL_WIDTH):
pool = self._get_pool_layer_func()
conv = get_conv_layer_func(len(self._get_shape(3)))
ave = get_ave_layer_func(len(self._get_shape(3)))
pooling_len = int(model_len / 4)
model = StubModel()
model.input_shape = self.input_shape
model.inputs = [0]
model.layers.append(StubInput())
for i in range(model_len):
model.layers += [
StubActivation('relu'),
StubConv(model_width, kernel_size=3, func=conv),
StubBatchNormalization(),
StubDropout(constant.CONV_DROPOUT_RATE)
]
if pooling_len == 0 or ((i + 1) % pooling_len == 0
and i != model_len - 1):
model.layers.append(StubPooling(func=pool))
model.layers.append(StubGlobalPooling(ave))
model.layers.append(StubDense(self.n_classes, activation='softmax'))
model.outputs = [len(model.layers)]
for index, layer in enumerate(model.layers):
layer.input = index
layer.output = index + 1
return Graph(model, False)
def generate(self,
model_len=Constant.MODEL_LEN,
model_width=Constant.MODEL_WIDTH):
pooling_len = int(model_len / 4)
graph = Graph(self.input_shape, False)
temp_input_channel = self.input_shape[-1]
output_node_id = 0
for i in range(model_len):
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(
StubConv(temp_input_channel, model_width, kernel_size=3),
output_node_id)
output_node_id = graph.add_layer(
StubBatchNormalization(model_width), output_node_id)
temp_input_channel = model_width
if pooling_len == 0 or ((i + 1) % pooling_len == 0
and i != model_len - 1):
output_node_id = graph.add_layer(StubPooling(), output_node_id)
output_node_id = graph.add_layer(StubFlatten(), output_node_id)
output_node_id = graph.add_layer(
StubDropout(Constant.CONV_DROPOUT_RATE), output_node_id)
output_node_id = graph.add_layer(
StubDense(graph.node_list[output_node_id].shape[0], model_width),
output_node_id)
output_node_id = graph.add_layer(StubReLU(), output_node_id)
output_node_id = graph.add_layer(
StubDense(model_width, self.n_classes), output_node_id)
graph.add_layer(StubSoftmax(), output_node_id)
return graph
def to_stub_model(model, weighted=False):
node_count = 0
tensor_dict = {}
ret = StubModel()
ret.input_shape = model.input_shape
for layer in model.layers:
if isinstance(layer.input, list):
input_nodes = layer.input
else:
input_nodes = [layer.input]
for node in input_nodes + [layer.output]:
if node not in tensor_dict:
tensor_dict[node] = StubTensor(get_int_tuple(node.shape))
node_count += 1
if isinstance(layer.input, list):
input_id = []
for node in layer.input:
input_id.append(tensor_dict[node])
else:
input_id = tensor_dict[layer.input]
output_id = tensor_dict[layer.output]
if is_conv_layer(layer):
temp_stub_layer = StubConv(layer.filters, layer.kernel_size,
layer.__class__, input_id, output_id)
elif isinstance(layer, Dense):
temp_stub_layer = StubDense(layer.units, layer.activation,
input_id, output_id)
elif isinstance(layer, WeightedAdd):
temp_stub_layer = StubWeightedAdd(input_id, output_id)
elif isinstance(layer, Concatenate):
temp_stub_layer = StubConcatenate(input_id, output_id)
elif isinstance(layer, BatchNormalization):
temp_stub_layer = StubBatchNormalization(input_id, output_id)
elif isinstance(layer, Activation):
temp_stub_layer = StubActivation(layer.activation, input_id,
output_id)
elif isinstance(layer, InputLayer):
temp_stub_layer = StubLayer(input_id, output_id)
elif isinstance(layer, Flatten):
temp_stub_layer = StubFlatten(input_id, output_id)
elif isinstance(layer, Dropout):
temp_stub_layer = StubDropout(layer.rate, input_id, output_id)
elif is_pooling_layer(layer):
temp_stub_layer = StubPooling(layer.__class__, input_id, output_id)
elif is_global_pooling_layer(layer):
temp_stub_layer = StubGlobalPooling(layer.__class__, input_id,
output_id)
else:
raise TypeError("The layer {} is illegal.".format(layer))
if weighted:
temp_stub_layer.set_weights(layer.get_weights())
ret.add_layer(temp_stub_layer)
ret.inputs = [tensor_dict[model.inputs[0]]]
ret.outputs = [tensor_dict[model.outputs[0]]]
return ret
def wider_bn(layer, start_dim, total_dim, n_add, weighted=True):
if not weighted:
return StubBatchNormalization(layer.num_features + n_add)
weights = layer.get_weights()
new_weights = [add_noise(np.ones(n_add, dtype=np.float32), np.array([0, 1])),
add_noise(np.zeros(n_add, dtype=np.float32), np.array([0, 1])),
add_noise(np.zeros(n_add, dtype=np.float32), np.array([0, 1])),
add_noise(np.ones(n_add, dtype=np.float32), np.array([0, 1]))]
student_w = tuple()
for weight, new_weight in zip(weights, new_weights):
temp_w = weight.copy()
temp_w = np.concatenate((temp_w[:start_dim], new_weight, temp_w[start_dim:total_dim]))
student_w += (temp_w,)
new_layer = StubBatchNormalization(layer.num_features + n_add)
new_layer.set_weights(student_w)
return new_layer
def wider_bn(layer, start_dim, total_dim, n_add, weighted=True):
if not weighted:
return StubBatchNormalization(layer.num_features + n_add)
weights = layer.get_weights()
new_weights = [add_noise(np.ones(n_add, dtype=np.float32), np.array([0, 1])),
add_noise(np.zeros(n_add, dtype=np.float32), np.array([0, 1])),
add_noise(np.zeros(n_add, dtype=np.float32), np.array([0, 1])),
add_noise(np.ones(n_add, dtype=np.float32), np.array([0, 1]))]
student_w = tuple()
for weight, new_weight in zip(weights, new_weights):
temp_w = weight.copy()
temp_w = np.concatenate((temp_w[:start_dim], new_weight, temp_w[start_dim:total_dim]))
student_w += (temp_w,)
new_layer = StubBatchNormalization(layer.num_features + n_add)
new_layer.set_weights(student_w)
return new_layer
def to_stub_model(model):
node_count = 0
node_to_id = {}
ret = StubModel()
ret.input_shape = model.input_shape
for layer in model.layers:
if isinstance(layer.input, list):
input_nodes = layer.input
else:
input_nodes = [layer.input]
for node in input_nodes + [layer.output]:
if node not in node_to_id:
node_to_id[node] = node_count
node_count += 1
if isinstance(layer.input, list):
input_id = []
for node in layer.input:
input_id.append(node_to_id[node])
else:
input_id = node_to_id[layer.input]
output_id = node_to_id[layer.output]
if is_conv_layer(layer):
temp_stub_layer = StubConv(layer.filters, input_id, output_id)
elif isinstance(layer, Dense):
temp_stub_layer = StubDense(layer.units, input_id, output_id)
elif isinstance(layer, WeightedAdd):
temp_stub_layer = StubWeightedAdd(input_id, output_id)
elif isinstance(layer, Concatenate):
temp_stub_layer = StubConcatenate(input_id, output_id)
elif isinstance(layer, BatchNormalization):
temp_stub_layer = StubBatchNormalization(input_id, output_id)
elif isinstance(layer, Activation):
temp_stub_layer = StubActivation(input_id, output_id)
elif isinstance(layer, InputLayer):
temp_stub_layer = StubLayer(input_id, output_id)
elif isinstance(layer, Flatten):
temp_stub_layer = StubLayer(input_id, output_id)
elif isinstance(layer, Dropout):
temp_stub_layer = StubLayer(input_id, output_id)
elif is_pooling_layer(layer):
temp_stub_layer = StubPooling(input_id, output_id)
else:
raise TypeError("The layer {} is illegal.".format(layer))
ret.add_layer(temp_stub_layer)
return ret
def _wider_bn(self, layer, start_dim, total_dim, n_add):
return StubBatchNormalization()
def to_concat_skip_model(self, start_id, end_id):
"""Add a weighted add concatenate connection from after start node to end node.
Args:
start_id: The convolutional layer ID, after which to start the skip-connection.
end_id: The convolutional layer ID, after which to end the skip-connection.
"""
self.operation_history.append(
('to_concat_skip_model', start_id, end_id))
conv_block_input_id = self._conv_block_end_node(start_id)
conv_block_input_id = self.adj_list[conv_block_input_id][0][0]
block_last_layer_input_id = self._conv_block_end_node(end_id)
# Add the pooling layer chain.
pooling_layer_list = self._get_pooling_layers(
conv_block_input_id, block_last_layer_input_id)
skip_output_id = conv_block_input_id
for index, layer_id in enumerate(pooling_layer_list):
skip_output_id = self.add_layer(
deepcopy(self.layer_list[layer_id]), skip_output_id)
block_last_layer_output_id = self.adj_list[block_last_layer_input_id][
0][0]
concat_input_node_id = self._add_node(
deepcopy(self.node_list[block_last_layer_output_id]))
self._redirect_edge(block_last_layer_input_id,
block_last_layer_output_id, concat_input_node_id)
concat_layer = StubConcatenate()
concat_layer.input = [
self.node_list[concat_input_node_id],
self.node_list[skip_output_id]
]
concat_output_node_id = self._add_node(Node(concat_layer.output_shape))
self._add_edge(concat_layer, concat_input_node_id,
concat_output_node_id)
self._add_edge(concat_layer, skip_output_id, concat_output_node_id)
concat_layer.output = self.node_list[concat_output_node_id]
self.node_list[concat_output_node_id].shape = concat_layer.output_shape
# Add the concatenate layer.
new_relu_layer = StubReLU()
concat_output_node_id = self.add_layer(new_relu_layer,
concat_output_node_id)
new_conv_layer = StubConv(
self.layer_list[start_id].filters +
self.layer_list[end_id].filters, self.layer_list[end_id].filters,
1)
concat_output_node_id = self.add_layer(new_conv_layer,
concat_output_node_id)
new_bn_layer = StubBatchNormalization(self.layer_list[end_id].filters)
self._add_edge(new_bn_layer, concat_output_node_id,
block_last_layer_output_id)
new_bn_layer.input = self.node_list[concat_output_node_id]
new_bn_layer.output = self.node_list[block_last_layer_output_id]
self.node_list[
block_last_layer_output_id].shape = new_bn_layer.output_shape
if self.weighted:
filters_end = self.layer_list[end_id].filters
filters_start = self.layer_list[start_id].filters
filter_shape = (1, ) * (
len(self.layer_list[end_id].get_weights()[0].shape) - 2)
weights = np.zeros((filters_end, filters_end) + filter_shape)
for i in range(filters_end):
filter_weight = np.zeros((filters_end, ) + filter_shape)
filter_weight[(i, 0, 0)] = 1
weights[i, ...] = filter_weight
weights = np.concatenate(
(weights,
np.zeros((filters_end, filters_start) + filter_shape)),
axis=1)
bias = np.zeros(filters_end)
new_conv_layer.set_weights((add_noise(weights, np.array([0, 1])),
add_noise(bias, np.array([0, 1]))))
n_filters = filters_end
new_weights = [
add_noise(np.ones(n_filters, dtype=np.float32),
np.array([0, 1])),
add_noise(np.zeros(n_filters, dtype=np.float32),
np.array([0, 1])),
add_noise(np.zeros(n_filters, dtype=np.float32),
np.array([0, 1])),
add_noise(np.ones(n_filters, dtype=np.float32),
np.array([0, 1]))
]
new_bn_layer.set_weights(new_weights)
def to_add_skip_model(self, start_id, end_id):
"""Add a weighted add skip-connection from after start node to end node.
Args:
start_id: The convolutional layer ID, after which to start the skip-connection.
end_id: The convolutional layer ID, after which to end the skip-connection.
"""
self.operation_history.append(('to_add_skip_model', start_id, end_id))
conv_block_input_id = self._conv_block_end_node(start_id)
conv_block_input_id = self.adj_list[conv_block_input_id][0][0]
block_last_layer_input_id = self._conv_block_end_node(end_id)
# Add the pooling layer chain.
layer_list = self._get_pooling_layers(conv_block_input_id,
block_last_layer_input_id)
skip_output_id = conv_block_input_id
for index, layer_id in enumerate(layer_list):
skip_output_id = self.add_layer(
deepcopy(self.layer_list[layer_id]), skip_output_id)
# Add the conv layer
new_relu_layer = StubReLU()
skip_output_id = self.add_layer(new_relu_layer, skip_output_id)
new_conv_layer = StubConv(self.layer_list[start_id].filters,
self.layer_list[end_id].filters, 1)
skip_output_id = self.add_layer(new_conv_layer, skip_output_id)
new_bn_layer = StubBatchNormalization(self.layer_list[end_id].filters)
skip_output_id = self.add_layer(new_bn_layer, skip_output_id)
# Add the add layer.
block_last_layer_output_id = self.adj_list[block_last_layer_input_id][
0][0]
add_input_node_id = self._add_node(
deepcopy(self.node_list[block_last_layer_output_id]))
add_layer = StubAdd()
self._redirect_edge(block_last_layer_input_id,
block_last_layer_output_id, add_input_node_id)
self._add_edge(add_layer, add_input_node_id,
block_last_layer_output_id)
self._add_edge(add_layer, skip_output_id, block_last_layer_output_id)
add_layer.input = [
self.node_list[add_input_node_id], self.node_list[skip_output_id]
]
add_layer.output = self.node_list[block_last_layer_output_id]
self.node_list[
block_last_layer_output_id].shape = add_layer.output_shape
# Set weights to the additional conv layer.
if self.weighted:
filters_end = self.layer_list[end_id].filters
filters_start = self.layer_list[start_id].filters
filter_shape = (1, ) * (
len(self.layer_list[end_id].get_weights()[0].shape) - 2)
weights = np.zeros((filters_end, filters_start) + filter_shape)
bias = np.zeros(filters_end)
new_conv_layer.set_weights((add_noise(weights, np.array([0, 1])),
add_noise(bias, np.array([0, 1]))))
n_filters = filters_end
new_weights = [
add_noise(np.ones(n_filters, dtype=np.float32),
np.array([0, 1])),
add_noise(np.zeros(n_filters, dtype=np.float32),
np.array([0, 1])),
add_noise(np.zeros(n_filters, dtype=np.float32),
np.array([0, 1])),
add_noise(np.ones(n_filters, dtype=np.float32),
np.array([0, 1]))
]
new_bn_layer.set_weights(new_weights)
def to_concat_skip_model(self, start_id, end_id):
"""Add a weighted add concatenate connection from after start node to end node.
Args:
start_id: The convolutional layer ID, after which to start the skip-connection.
end_id: The convolutional layer ID, after which to end the skip-connection.
"""
self.operation_history.append(('to_concat_skip_model', start_id, end_id))
conv_block_input_id = self._conv_block_end_node(start_id)
conv_block_input_id = self.adj_list[conv_block_input_id][0][0]
block_last_layer_input_id = self._conv_block_end_node(end_id)
# Add the pooling layer chain.
pooling_layer_list = self._get_pooling_layers(conv_block_input_id, block_last_layer_input_id)
skip_output_id = conv_block_input_id
for index, layer_id in enumerate(pooling_layer_list):
skip_output_id = self.add_layer(deepcopy(self.layer_list[layer_id]), skip_output_id)
block_last_layer_output_id = self.adj_list[block_last_layer_input_id][0][0]
concat_input_node_id = self._add_node(deepcopy(self.node_list[block_last_layer_output_id]))
self._redirect_edge(block_last_layer_input_id, block_last_layer_output_id, concat_input_node_id)
concat_layer = StubConcatenate()
concat_layer.input = [self.node_list[concat_input_node_id], self.node_list[skip_output_id]]
concat_output_node_id = self._add_node(Node(concat_layer.output_shape))
self._add_edge(concat_layer, concat_input_node_id, concat_output_node_id)
self._add_edge(concat_layer, skip_output_id, concat_output_node_id)
concat_layer.output = self.node_list[concat_output_node_id]
self.node_list[concat_output_node_id].shape = concat_layer.output_shape
# Add the concatenate layer.
new_relu_layer = StubReLU()
concat_output_node_id = self.add_layer(new_relu_layer, concat_output_node_id)
new_conv_layer = StubConv(self.layer_list[start_id].filters + self.layer_list[end_id].filters,
self.layer_list[end_id].filters, 1)
concat_output_node_id = self.add_layer(new_conv_layer, concat_output_node_id)
new_bn_layer = StubBatchNormalization(self.layer_list[end_id].filters)
self._add_edge(new_bn_layer, concat_output_node_id, block_last_layer_output_id)
new_bn_layer.input = self.node_list[concat_output_node_id]
new_bn_layer.output = self.node_list[block_last_layer_output_id]
self.node_list[block_last_layer_output_id].shape = new_bn_layer.output_shape
if self.weighted:
filters_end = self.layer_list[end_id].filters
filters_start = self.layer_list[start_id].filters
filter_shape = (1,) * (len(self.layer_list[end_id].get_weights()[0].shape) - 2)
weights = np.zeros((filters_end, filters_end) + filter_shape)
for i in range(filters_end):
filter_weight = np.zeros((filters_end,) + filter_shape)
filter_weight[(i, 0, 0)] = 1
weights[i, ...] = filter_weight
weights = np.concatenate((weights,
np.zeros((filters_end, filters_start) + filter_shape)), axis=1)
bias = np.zeros(filters_end)
new_conv_layer.set_weights((add_noise(weights, np.array([0, 1])), add_noise(bias, np.array([0, 1]))))
n_filters = filters_end
new_weights = [add_noise(np.ones(n_filters, dtype=np.float32), np.array([0, 1])),
add_noise(np.zeros(n_filters, dtype=np.float32), np.array([0, 1])),
add_noise(np.zeros(n_filters, dtype=np.float32), np.array([0, 1])),
add_noise(np.ones(n_filters, dtype=np.float32), np.array([0, 1]))]
new_bn_layer.set_weights(new_weights)
def _deeper_conv_block(self, target, kernel_size):
return [
StubConv(self._layer_width(target)),
StubBatchNormalization(),
StubActivation()
]
