def dense_block(self, blocks):
for i in range(blocks):
self.append_layer(Layers.BatchNormalizationLayer())
self.append_layer(Layers.ActivationLayer('relu'))
self.append_layer(Layers.ConvLayer(4 * 32, 1, 1,
use_bias_in=False))
self.append_layer(Layers.BatchNormalizationLayer())
self.append_layer(Layers.ActivationLayer('relu'))
self.append_layer(
Layers.ConvLayer(32,
3,
1,
padding_in='same',
use_bias_in=False))
self.append_layer(Layers.ConcatenateLayer(concatenate=True))
def test_layer(self):
self.append_layer(Layers.ZeroPaddingLayer(3))
self.append_layer(Layers.ConvLayer(64, 7, 2, use_bias_in=False))
self.append_layer(Layers.BatchNormalizationLayer())
self.append_layer(Layers.ActivationLayer('relu'))
self.append_layer(Layers.ZeroPaddingLayer(1))
self.append_layer(
Layers.PoolLayer(3, 2, type_in='max', concatenate=True))
self.dense_block(6)
self.transition_block(128)
self.dense_block(12)
self.transition_block(256)
self.dense_block(32)
self.transition_block(640)
self.dense_block(32)
self.append_layer(Layers.BatchNormalizationLayer())
self.append_layer(Layers.PoolLayer(2, 2, pool_type_in='globalaverage'))
self.append_layer(Layers.ActivationLayer('sigmoid'))
def transition_block(self, conv_in):
self.append_layer(Layers.BatchNormalizationLayer())
self.append_layer(Layers.ActivationLayer('relu'))
self.append_layer(Layers.ConvLayer(conv_in, 1, 1, use_bias_in=False))
self.append_layer(
Layers.PoolLayer(2, 2, type_in='average', concatenate=True))
def __init__(self, input, input_shape, rng=None, Ws=None, bs=None):
assert(
(rng is None and Ws is None and bs is None) or
(rng is not None and Ws is None and bs is None) or
(rng is None and Ws is not None and bs is not None)
)
if Ws is None and bs is None:
Ws = [None] * 5
bs = [None] * 5
self.trainable_layers = []
############################## conv1 ##############################
self.layer_conv1 = Layers.ConvLayer(
input=input,
input_shape=input_shape,
filter_shape=(96, 3, 11, 11),
stride=(4, 4),
border_mode='valid',
activation=T.nnet.relu,
rng=rng,
W=Ws[0],
b=bs[0]
)
conv1_output_shape = (None, 96, 55, 55) # (227 - 11) / 4 + 1 = 55
self.trainable_layers.append(self.layer_conv1)
self.layer_pool1 = Layers.PoolLayer(
input=self.layer_conv1.output,
kernel_size=(3, 3),
stride=(2, 2)
)
pool1_output_shape = (None, 96, 27, 27) # (55 - 3) / 2 + 1 = 27
self.layer_norm1 = normalization.LocalResponseNormalization2DLayer(
incoming=pool1_output_shape, # Actual input is param to .get_output_for()
# alpha=0.0001,
alpha=0.0001/5, # Caffe documentation uses alpha/n as coeff of summation
k=1, # Not specified; Caffe says default is 1, but AlexNet paper says 2
beta=0.75,
n=5
)
self.layer_norm1.output = self.layer_norm1.get_output_for(self.layer_pool1.output)
self.layer_norm1.output_group1 = self.layer_norm1.output[:, :48, :, :]
self.layer_norm1.output_group2 = self.layer_norm1.output[:, 48:, :, :]
norm1_group1_output_shape = (None, 48, 27, 27)
norm1_group2_output_shape = (None, 48, 27, 27)
############################## conv2 ##############################
self.layer_conv2_group1 = Layers.ConvLayer(
input=self.layer_norm1.output_group1,
input_shape=norm1_group1_output_shape,
filter_shape=(128, 48, 5, 5),
stride=(1, 1),
border_mode=(2, 2), # pad by 2 pixels to each edge, so height and width += 4
activation=T.nnet.relu,
rng=rng,
W=Ws[1][:128] if Ws[1] is not None else None,
b=bs[1][:128] if bs[1] is not None else None
)
conv2_group1_output_shape = (None, 128, 27, 27) # (27 + 4 - 5) / 1 + 1 = 27
self.trainable_layers.append(self.layer_conv2_group1)
self.layer_conv2_group2 = Layers.ConvLayer(
input=self.layer_norm1.output_group2,
input_shape=norm1_group2_output_shape,
filter_shape=(128, 48, 5, 5),
stride=(1, 1),
border_mode=(2, 2), # pad by 2 pixels to each edge, so height and width += 4
activation=T.nnet.relu,
rng=rng,
W=Ws[1][128:] if Ws[1] is not None else None,
b=bs[1][128:] if bs[1] is not None else None
)
conv2_group2_output_shape = (None, 128, 27, 27) # (27 + 4 - 5) / 1 + 1 = 27
self.trainable_layers.append(self.layer_conv2_group2)
self.layer_pool2_group1 = Layers.PoolLayer(
input=self.layer_conv2_group1.output,
kernel_size=(3, 3),
stride=(2, 2)
)
pool2_group1_output_shape = (None, 128, 13, 13) # (27 - 3) / 2 + 1 = 13
self.layer_pool2_group2 = Layers.PoolLayer(
input=self.layer_conv2_group2.output,
kernel_size=(3, 3),
stride=(2, 2)
)
pool2_group2_output_shape = (None, 128, 13, 13) # (27 - 3) / 2 + 1 = 13
self.layer_norm2_group1 = normalization.LocalResponseNormalization2DLayer(
incoming=pool2_group1_output_shape, # Actual input is param to .get_output_for()
# alpha=0.0001,
alpha=0.0001/5, # Caffe documentation uses alpha/n as coeff of summation
k=1, # Not specified; Caffe says default is 1
beta=0.75,
n=5
)
self.layer_norm2_group1.output = self.layer_norm2_group1.get_output_for(self.layer_pool2_group1.output)
norm2_group1_output_shape = pool2_group1_output_shape
self.layer_norm2_group2 = normalization.LocalResponseNormalization2DLayer(
incoming=pool2_group2_output_shape, # Actual input is param to .get_output_for()
# alpha=0.0001,
alpha=0.0001/5, # Caffe documentation uses alpha/n as coeff of summation
k=1, # Not specified; Caffe says default is 1
beta=0.75,
n=5
)
self.layer_norm2_group2.output = self.layer_norm2_group2.get_output_for(self.layer_pool2_group2.output)
norm2_group2_output_shape = pool2_group2_output_shape
############################## conv3 ##############################
norm2_grouped_output = T.concatenate((self.layer_norm2_group1.output, self.layer_norm2_group2.output), axis=1)
norm2_grouped_output_shape = (None, 256, 13, 13)
self.layer_conv3 = Layers.ConvLayer(
input=norm2_grouped_output,
input_shape=norm2_grouped_output_shape,
filter_shape=(384, 256, 3, 3),
stride=(1, 1),
border_mode=(1, 1),
activation=T.nnet.relu,
rng=rng,
W=Ws[2],
b=bs[2]
)
conv3_output_shape = (None, 384, 13, 13) # (13 + 2 - 3) / 1 + 1 = 13
self.trainable_layers.append(self.layer_conv3)
self.layer_conv3.output_group1 = self.layer_conv3.output[:, :192, :, :]
self.layer_conv3.output_group2 = self.layer_conv3.output[:, 192:, :, :]
conv3_group1_output_shape = (None, 192, 13, 13)
conv3_group2_output_shape = (None, 192, 13, 13)
############################## conv4 ##############################
self.layer_conv4_group1 = Layers.ConvLayer(
input=self.layer_conv3.output_group1,
input_shape=conv3_group1_output_shape,
filter_shape=(192, 192, 3, 3),
stride=(1, 1),
border_mode=(1, 1),
activation=T.nnet.relu,
rng=rng,
W=Ws[3][:192] if Ws[3] is not None else None,
b=bs[3][:192] if bs[3] is not None else None
)
conv4_group1_output_shape = (None, 192, 13, 13) # (13 + 2 - 3) / 1 + 1 = 13
self.trainable_layers.append(self.layer_conv4_group1)
self.layer_conv4_group2 = Layers.ConvLayer(
input=self.layer_conv3.output_group2,
input_shape=conv3_group2_output_shape,
filter_shape=(192, 192, 3, 3),
stride=(1, 1),
border_mode=(1, 1),
activation=T.nnet.relu,
rng=rng,
W=Ws[3][192:] if Ws[3] is not None else None,
b=bs[3][192:] if bs[3] is not None else None
)
conv4_group2_output_shape = (None, 192, 13, 13) # (13 + 2 - 3) / 1 + 1 = 13
self.trainable_layers.append(self.layer_conv4_group2)
############################## conv5 ##############################
self.layer_conv5_group1 = Layers.ConvLayer(
input=self.layer_conv4_group1.output,
input_shape=conv4_group1_output_shape,
filter_shape=(128, 192, 3, 3),
stride=(1, 1),
border_mode=(1, 1),
activation=T.nnet.relu,
rng=rng,
W=Ws[4][:128] if Ws[4] is not None else None,
b=bs[4][:128] if bs[4] is not None else None
)
conv5_group1_output_shape = (None, 128, 13, 13) # (13 + 2 - 3) / 1 + 1 = 13
self.trainable_layers.append(self.layer_conv5_group1)
self.layer_pool5_group1 = Layers.PoolLayer(
input=self.layer_conv5_group1.output,
kernel_size=(3, 3),
stride=(2, 2)
)
pool5_group1_output_shape = (None, 128, 6, 6) # (13 - 3) / 2 + 1 = 6
self.layer_conv5_group2 = Layers.ConvLayer(
input=self.layer_conv4_group2.output,
input_shape=conv4_group2_output_shape,
filter_shape=(128, 192, 3, 3),
stride=(1, 1),
border_mode=(1, 1),
activation=T.nnet.relu,
rng=rng,
W=Ws[4][128:] if Ws[4] is not None else None,
b=bs[4][128:] if bs[4] is not None else None
)
conv5_group2_output_shape = (None, 128, 13, 13) # (13 + 2 - 3) / 1 + 1 = 13
self.trainable_layers.append(self.layer_conv5_group2)
self.layer_pool5_group2 = Layers.PoolLayer(
input=self.layer_conv5_group2.output,
kernel_size=(3, 3),
stride=(2, 2)
)
pool5_group2_output_shape = (None, 128, 6, 6) # (13 - 3) / 2 + 1 = 6
pool5_grouped_output = T.concatenate((self.layer_pool5_group1.output, self.layer_pool5_group2.output), axis=1)
self.output = pool5_grouped_output
self.trainable_params = [param for layer in self.trainable_layers for param in layer.params]
