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 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): 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( StubConv(temp_input_channel, model_width, kernel_size=3), output_node_id) output_node_id = graph.add_layer( StubBatchNormalization(model_width), output_node_id) output_node_id = graph.add_layer(StubReLU(), 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) graph.add_layer(StubDense(model_width, self.n_output_node), output_node_id) return graph
def wider_next_conv(layer, start_dim, total_dim, n_add, weighted=True): if not weighted: return StubConv(layer.input_channel + n_add, layer.filters, kernel_size=layer.kernel_size) n_filters = layer.filters teacher_w, teacher_b = layer.get_weights() new_weight_shape = list(teacher_w.shape) new_weight_shape[1] = n_add new_weight = np.zeros(tuple(new_weight_shape)) student_w = np.concatenate((teacher_w[:, :start_dim, ...].copy(), add_noise(new_weight, teacher_w), teacher_w[:, start_dim:total_dim, ...].copy()), axis=1) new_layer = StubConv(layer.input_channel + n_add, n_filters, layer.kernel_size) new_layer.set_weights((student_w, teacher_b)) return new_layer
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 deeper_conv_block(conv_layer, kernel_size, weighted=True): """Get deeper layer for convolution layer Args: weighted: conv_layer: the convolution layer from which we get deeper layer kernel_size: the size of kernel Returns: The deeper convolution layer """ filter_shape = (kernel_size, ) * (len(conv_layer.kernel_size)) 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 [ bn, StubActivation('relu'), new_conv_layer, StubDropout(constant.CONV_DROPOUT_RATE) ]
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] dropout_input_id = self._conv_block_end_node(end_id) # Add the pooling layer chain. layer_list = self._get_pooling_layers(conv_block_input_id, dropout_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_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) # Add the add layer. dropout_output_id = self.adj_list[dropout_input_id][0][0] add_input_node_id = self._add_node(deepcopy(self.node_list[dropout_output_id])) add_layer = StubAdd() self._redirect_edge(dropout_input_id, dropout_output_id, add_input_node_id) self._add_edge(add_layer, add_input_node_id, dropout_output_id) self._add_edge(add_layer, skip_output_id, dropout_output_id) add_layer.input = [self.node_list[add_input_node_id], self.node_list[skip_output_id]] add_layer.output = self.node_list[dropout_output_id] self.node_list[dropout_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]))))
def get_pooling_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) output_node_id = graph.add_layer(StubPooling(2), 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) 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 wider_pre_conv(layer, n_add_filters, weighted=True): if not weighted: return StubConv(layer.input_channel, layer.filters + n_add_filters, kernel_size=layer.kernel_size) n_pre_filters = layer.filters rand = np.random.randint(n_pre_filters, size=n_add_filters) teacher_w, teacher_b = layer.get_weights() student_w = teacher_w.copy() student_b = teacher_b.copy() # target layer update (i) for i in range(len(rand)): teacher_index = rand[i] new_weight = teacher_w[teacher_index, ...] new_weight = new_weight[np.newaxis, ...] student_w = np.concatenate((student_w, new_weight), axis=0) student_b = np.append(student_b, teacher_b[teacher_index]) new_pre_layer = StubConv(layer.input_channel, n_pre_filters + n_add_filters, layer.kernel_size) new_pre_layer.set_weights((add_noise(student_w, teacher_w), add_noise(student_b, teacher_b))) return new_pre_layer
def wider_next_conv(layer, start_dim, total_dim, n_add, weighted=True): if not weighted: return StubConv(layer.input_channel + n_add, layer.filters, kernel_size=layer.kernel_size) n_filters = layer.filters teacher_w, teacher_b = layer.get_weights() new_weight_shape = list(teacher_w.shape) new_weight_shape[1] = n_add new_weight = np.zeros(tuple(new_weight_shape)) student_w = np.concatenate( (teacher_w[:, :start_dim, ...].copy(), add_noise( new_weight, teacher_w), teacher_w[:, start_dim:total_dim, ...].copy()), axis=1) new_layer = StubConv(layer.input_channel + n_add, n_filters, layer.kernel_size) new_layer.set_weights((student_w, teacher_b)) return new_layer
def wider_next_conv(layer, start_dim, total_dim, n_add, weighted=True): if not weighted: return StubConv(layer.filters, kernel_size=layer.kernel_size, func=layer.func) filter_shape = layer.kernel_size n_filters = layer.filters teacher_w, teacher_b = layer.get_weights() new_weight_shape = list(teacher_w.shape) new_weight_shape[-2] = n_add new_weight = np.zeros(tuple(new_weight_shape)) student_w = np.concatenate( (teacher_w[..., :start_dim, :].copy(), add_noise( new_weight, teacher_w), teacher_w[..., start_dim:total_dim, :].copy()), axis=-2) new_layer = StubConv(n_filters, kernel_size=filter_shape, func=layer.func) new_layer.set_weights((student_w, teacher_b)) return new_layer
def get_concat_skip_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) 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(StubConcatenate(), [output_node_id, temp_node_id]) output_node_id = graph.add_layer(StubReLU(), output_node_id) output_node_id = graph.add_layer(StubConv(6, 3, 1), output_node_id) output_node_id = graph.add_layer(StubBatchNormalization(3), 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(StubConcatenate(), [output_node_id, temp_node_id]) output_node_id = graph.add_layer(StubReLU(), output_node_id) output_node_id = graph.add_layer(StubConv(6, 3, 1), 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.CONV_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 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 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] dropout_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, dropout_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) # Add the concatenate layer. new_conv_layer = StubConv(self.layer_list[start_id].filters + self.layer_list[end_id].filters, self.layer_list[end_id].filters, 1) dropout_output_id = self.adj_list[dropout_input_id][0][0] concat_input_node_id = self._add_node(deepcopy(self.node_list[dropout_output_id])) self._redirect_edge(dropout_input_id, dropout_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 self._add_edge(new_conv_layer, concat_output_node_id, dropout_output_id) new_conv_layer.input = self.node_list[concat_output_node_id] new_conv_layer.output = self.node_list[dropout_output_id] self.node_list[dropout_output_id].shape = new_conv_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]))))
def _deeper_conv_block(self, target, kernel_size): return [ StubConv(self._layer_width(target)), StubBatchNormalization(), StubActivation() ]
def _wider_pre_conv(self, layer, n_add): return StubConv(self._layer_width(layer) + n_add)
def _wider_next_conv(self, layer, start_dim, total_dim, n_add): return StubConv(self._layer_width(layer))
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 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)