Python lasagne.layers.BatchNormLayer() Examples
The following are 13
code examples of lasagne.layers.BatchNormLayer().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
lasagne.layers
, or try the search function
.
.
Example #1
| Source File: densenet_fast.py From Recipes with MIT License | 5 votes |
|
def dense_block(network, num_layers, growth_rate, dropout, name_prefix):
# concatenated 3x3 convolutions
for n in range(num_layers):
conv = affine_relu_conv(network, channels=growth_rate,
filter_size=3, dropout=dropout,
name_prefix=name_prefix + '_l%02d' % (n + 1))
conv = BatchNormLayer(conv, name=name_prefix + '_l%02dbn' % (n + 1),
beta=None, gamma=None)
network = ConcatLayer([network, conv], axis=1,
name=name_prefix + '_l%02d_join' % (n + 1))
return network
Example #2
| Source File: densenet_fast.py From Recipes with MIT License | 5 votes |
|
def transition(network, dropout, name_prefix):
# a transition 1x1 convolution followed by avg-pooling
network = affine_relu_conv(network, channels=network.output_shape[1],
filter_size=1, dropout=dropout,
name_prefix=name_prefix)
network = Pool2DLayer(network, 2, mode='average_inc_pad',
name=name_prefix + '_pool')
network = BatchNormLayer(network, name=name_prefix + '_bn',
beta=None, gamma=None)
return network
Example #3
| Source File: densenet.py From Recipes with MIT License | 5 votes |
|
def bn_relu_conv(network, channels, filter_size, dropout, name_prefix):
network = BatchNormLayer(network, name=name_prefix + '_bn')
network = NonlinearityLayer(network, nonlinearity=rectify,
name=name_prefix + '_relu')
network = Conv2DLayer(network, channels, filter_size, pad='same',
W=lasagne.init.HeNormal(gain='relu'),
b=None, nonlinearity=None,
name=name_prefix + '_conv')
if dropout:
network = DropoutLayer(network, dropout)
return network
Example #4
| Source File: res_net_blocks.py From dcase_task2 with MIT License | 5 votes |
|
def residual_block(l, increase_dim=False, projection=True, first=False):
"""
Create a residual learning building block with two stacked 3x3 convlayers as in paper
'Identity Mappings in Deep Residual Networks', Kaiming He et al. 2016 (https://arxiv.org/abs/1603.05027)
"""
input_num_filters = l.output_shape[1]
if increase_dim:
first_stride = (2, 2)
out_num_filters = input_num_filters * 2
else:
first_stride = (1, 1)
out_num_filters = input_num_filters
if first:
# hacky solution to keep layers correct
bn_pre_relu = l
else:
# contains the BN -> ReLU portion, steps 1 to 2
bn_pre_conv = BatchNormLayer(l)
bn_pre_relu = NonlinearityLayer(bn_pre_conv, rectify)
# contains the weight -> BN -> ReLU portion, steps 3 to 5
conv_1 = batch_norm(ConvLayer(bn_pre_relu, num_filters=out_num_filters, filter_size=(3, 3), stride=first_stride,
nonlinearity=rectify, pad='same', W=he_norm))
# contains the last weight portion, step 6
conv_2 = ConvLayer(conv_1, num_filters=out_num_filters, filter_size=(3, 3), stride=(1, 1), nonlinearity=None,
pad='same', W=he_norm)
# add shortcut connections
if increase_dim:
# projection shortcut, as option B in paper
projection = ConvLayer(l, num_filters=out_num_filters, filter_size=(1, 1), stride=(2, 2), nonlinearity=None,
pad='same', b=None)
block = ElemwiseSumLayer([conv_2, projection])
else:
block = ElemwiseSumLayer([conv_2, l])
return block
Example #5
| Source File: res_net_blocks.py From dcase_task2 with MIT License | 5 votes |
|
def ResNet_FullPreActivation(input_shape=(None, 3, PIXELS, PIXELS), input_var=None, n_classes=10, n=18):
"""
Adapted from https://github.com/Lasagne/Recipes/tree/master/papers/deep_residual_learning.
Tweaked to be consistent with 'Identity Mappings in Deep Residual Networks', Kaiming He et al. 2016 (https://arxiv.org/abs/1603.05027)
Formula to figure out depth: 6n + 2
"""
# Building the network
l_in = InputLayer(shape=input_shape, input_var=input_var)
# first layer, output is 16 x 32 x 32
l = batch_norm(ConvLayer(l_in, num_filters=16, filter_size=(3, 3), stride=(1, 1), nonlinearity=rectify, pad='same', W=he_norm))
# first stack of residual blocks, output is 16 x 32 x 32
l = residual_block(l, first=True)
for _ in range(1, n):
l = residual_block(l)
# second stack of residual blocks, output is 32 x 16 x 16
l = residual_block(l, increase_dim=True)
for _ in range(1, n):
l = residual_block(l)
# third stack of residual blocks, output is 64 x 8 x 8
l = residual_block(l, increase_dim=True)
for _ in range(1, n):
l = residual_block(l)
bn_post_conv = BatchNormLayer(l)
bn_post_relu = NonlinearityLayer(bn_post_conv, rectify)
# average pooling
avg_pool = GlobalPoolLayer(bn_post_relu)
# fully connected layer
network = DenseLayer(avg_pool, num_units=n_classes, W=HeNormal(), nonlinearity=softmax)
return network
Example #6
| Source File: layers.py From FRRN with MIT License | 4 votes |
|
def get_output_for(self, input, deterministic=False,
batch_norm_use_averages=None,
batch_norm_update_averages=None, **kwargs):
# If the BN vars shall be updates as before, redirect to the parent
# implementation.
if not isinstance(batch_norm_update_averages, dict):
return super(BatchNormLayer, self).get_output_for(
input, deterministic, batch_norm_use_averages,
batch_norm_update_averages, **kwargs)
else:
input_mean = input.mean(self.axes)
input_inv_std = T.inv(T.sqrt(input.var(self.axes) + self.epsilon))
# Decide whether to use the stored averages or mini-batch statistics
if batch_norm_use_averages is None:
batch_norm_use_averages = deterministic
use_averages = batch_norm_use_averages
if use_averages:
mean = self.mean
inv_std = self.inv_std
else:
mean = input_mean
inv_std = input_inv_std
# Instead of automatically updating the averages, we add the update
# ops to a dictionary.
update_averages = batch_norm_update_averages
if isinstance(update_averages, dict):
update_averages[self.mean] = ((1 - self.alpha) * self.mean +
self.alpha * input_mean)
update_averages[self.inv_std] = ((1 - self.alpha) *
self.inv_std + self.alpha *
input_inv_std)
# prepare dimshuffle pattern inserting broadcastable axes as needed
param_axes = iter(range(input.ndim - len(self.axes)))
pattern = ['x' if input_axis in self.axes
else next(param_axes)
for input_axis in range(input.ndim)]
# apply dimshuffle pattern to all parameters
beta = 0 if self.beta is None else self.beta.dimshuffle(pattern)
gamma = 1 if self.gamma is None else self.gamma.dimshuffle(pattern)
mean = mean.dimshuffle(pattern)
inv_std = inv_std.dimshuffle(pattern)
# normalize
normalized = (input - mean) * (gamma * inv_std) + beta
return normalized
Example #7
| Source File: res_net_blocks.py From dcase_task2 with MIT License | 4 votes |
|
def residual_bottleneck_block(l, increase_dim=False, first=False):
"""
Create a residual learning building block with two stacked 3x3 conv layers as in paper
'Identity Mappings in Deep Residual Networks', Kaiming He et al. 2016 (https://arxiv.org/abs/1603.05027)
"""
input_num_filters = l.output_shape[1]
if increase_dim:
first_stride = (2, 2)
out_num_filters = input_num_filters * 2
else:
first_stride = (1, 1)
out_num_filters = input_num_filters
if first:
# hacky solution to keep layers correct
bn_pre_relu = l
out_num_filters = out_num_filters * 4
else:
# contains the BN -> ReLU portion, steps 1 to 2
bn_pre_conv = BatchNormLayer(l)
bn_pre_relu = NonlinearityLayer(bn_pre_conv, rectify)
bottleneck_filters = out_num_filters / 4
# contains the weight -> BN -> ReLU portion, steps 3 to 5
conv_1 = batch_norm(
ConvLayer(bn_pre_relu, num_filters=bottleneck_filters, filter_size=(1, 1), stride=(1, 1), nonlinearity=rectify,
pad='same', W=he_norm))
conv_2 = batch_norm(
ConvLayer(conv_1, num_filters=bottleneck_filters, filter_size=(3, 3), stride=first_stride, nonlinearity=rectify,
pad='same', W=he_norm))
# contains the last weight portion, step 6
conv_3 = ConvLayer(conv_2, num_filters=out_num_filters, filter_size=(1, 1), stride=(1, 1), nonlinearity=None,
pad='same', W=he_norm)
if increase_dim:
# projection shortcut, as option B in paper
projection = ConvLayer(l, num_filters=out_num_filters, filter_size=(1, 1), stride=(2, 2), nonlinearity=None,
pad='same', b=None)
block = ElemwiseSumLayer([conv_3, projection])
elif first:
# projection shortcut, as option B in paper
projection = ConvLayer(l, num_filters=out_num_filters, filter_size=(1, 1), stride=(1, 1), nonlinearity=None,
pad='same', b=None)
block = ElemwiseSumLayer([conv_3, projection])
else:
block = ElemwiseSumLayer([conv_3, l])
return block
Example #8
| Source File: res_net_blocks.py From dcase_task2 with MIT License | 4 votes |
|
def residual_wide_block(l, increase_dim=False, projection=True, first=False, filters=16):
""" Create a residual learning building block with two stacked 3x3 conv layers as in paper """
if increase_dim:
first_stride = (2, 2)
else:
first_stride = (1, 1)
if first:
# hacky solution to keep layers correct
bn_pre_relu = l
else:
# contains the BN -> ReLU portion, steps 1 to 2
bn_pre_conv = BatchNormLayer(l)
bn_pre_relu = NonlinearityLayer(bn_pre_conv, rectify)
# contains the weight -> BN -> ReLU portion, steps 3 to 5
conv_1 = batch_norm(
ConvLayer(bn_pre_relu, num_filters=filters, filter_size=(3, 3), stride=first_stride, nonlinearity=rectify,
pad='same', W=he_norm))
dropout = DropoutLayer(conv_1, p=0.3)
# contains the last weight portion, step 6
conv_2 = ConvLayer(dropout, num_filters=filters, filter_size=(3, 3), stride=(1, 1), nonlinearity=None, pad='same',
W=he_norm)
# add shortcut connections
if increase_dim:
# projection shortcut, as option B in paper
projection = ConvLayer(l, num_filters=filters, filter_size=(1, 1), stride=(2, 2), nonlinearity=None, pad='same',
b=None)
block = ElemwiseSumLayer([conv_2, projection])
elif first:
# projection shortcut, as option B in paper
projection = ConvLayer(l, num_filters=filters, filter_size=(1, 1), stride=(1, 1), nonlinearity=None, pad='same',
b=None)
block = ElemwiseSumLayer([conv_2, projection])
else:
block = ElemwiseSumLayer([conv_2, l])
return block
Example #9
| Source File: res_net_blocks.py From dcase_task2 with MIT License | 4 votes |
|
def ResNet_BottleNeck_FullPreActivation(input_shape=(None, 3, PIXELS, PIXELS), input_var=None, n_classes=10, n=18):
'''
Adapted from https://github.com/Lasagne/Recipes/tree/master/papers/deep_residual_learning.
Tweaked to be consistent with 'Identity Mappings in Deep Residual Networks', Kaiming He et al. 2016 (https://arxiv.org/abs/1603.05027)
Judging from https://github.com/KaimingHe/resnet-1k-layers/blob/master/resnet-pre-act.lua.
Number of filters go 16 -> 64 -> 128 -> 256
Forumala to figure out depth: 9n + 2
'''
# Building the network
l_in = InputLayer(shape=input_shape, input_var=input_var)
# first layer, output is 16x16x16
l = batch_norm(ConvLayer(l_in, num_filters=16, filter_size=(3, 3), stride=(1, 1), nonlinearity=rectify, pad='same', W=he_norm))
# first stack of residual blocks, output is 64x16x16
l = residual_bottleneck_block(l, first=True)
for _ in range(1, n):
l = residual_bottleneck_block(l)
# second stack of residual blocks, output is 128x8x8
l = residual_bottleneck_block(l, increase_dim=True)
for _ in range(1, n):
l = residual_bottleneck_block(l)
# third stack of residual blocks, output is 256x4x4
l = residual_bottleneck_block(l, increase_dim=True)
for _ in range(1, n):
l = residual_bottleneck_block(l)
bn_post_conv = BatchNormLayer(l)
bn_post_relu = NonlinearityLayer(bn_post_conv, rectify)
# average pooling
avg_pool = GlobalPoolLayer(bn_post_relu)
# fully connected layer
network = DenseLayer(avg_pool, num_units=n_classes, W=HeNormal(), nonlinearity=softmax)
return network
Example #10
| Source File: j0_mxnet.py From kaggle-heart with MIT License | 4 votes |
|
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:singleslice:difference"]
l0 = InputLayer(input_size)
# add channel layer
# l0r = reshape(l0, (-1, 1, ) + input_size[1:])
# (batch, channel, time, x, y)
l = ConvolutionOver2DAxisLayer(l0, num_filters=40, filter_size=(5, 5),
axis=(2,3), channel=1,
W=lasagne.init.Orthogonal(),
b=lasagne.init.Constant(0.1),
nonlinearity=lasagne.nonlinearities.identity
)
l = BatchNormLayer(l, gamma=None)
l = lasagne.layers.NonlinearityLayer(l, nonlinearity=lasagne.nonlinearities.rectify)
l = MaxPoolOver2DAxisLayer(l, pool_size=(2, 2), axis=(2,3), stride=(2,2))
l = ConvolutionOver2DAxisLayer(l, num_filters=40, filter_size=(3, 3),
axis=(2,3), channel=1,
W=lasagne.init.Orthogonal(),
b=lasagne.init.Constant(0.1),
nonlinearity=lasagne.nonlinearities.identity
)
l = BatchNormLayer(l, gamma=None)
l = lasagne.layers.NonlinearityLayer(l, nonlinearity=lasagne.nonlinearities.rectify)
l = MaxPoolOver2DAxisLayer(l, pool_size=(2, 2), axis=(2,3), stride=(2,2))
l_systole = lasagne.layers.DenseLayer(lasagne.layers.DropoutLayer(l),
num_units=600,
nonlinearity=lasagne.nonlinearities.softmax)
l_diastole = lasagne.layers.DenseLayer(lasagne.layers.DropoutLayer(l),
num_units=600,
nonlinearity=lasagne.nonlinearities.softmax)
return {
"inputs":{
"sliced:data:singleslice:difference": l0
},
"outputs": {
"systole:onehot": l_systole,
"diastole:onehot": l_diastole,
}
}
Example #11
| Source File: j0_mxnet1.py From kaggle-heart with MIT License | 4 votes |
|
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:singleslice:difference:middle"]
l0 = InputLayer(input_size)
# add channel layer
# l0r = reshape(l0, (-1, 1, ) + input_size[1:])
# (batch, channel, time, x, y)
l = ConvolutionOver2DAxisLayer(l0, num_filters=40, filter_size=(5, 5),
axis=(2,3), channel=1,
W=lasagne.init.Orthogonal(),
b=lasagne.init.Constant(0.1),
nonlinearity=lasagne.nonlinearities.identity
)
l = BatchNormLayer(l, gamma=None)
l = lasagne.layers.NonlinearityLayer(l, nonlinearity=lasagne.nonlinearities.rectify)
l = MaxPoolOver2DAxisLayer(l, pool_size=(2, 2), axis=(2,3), stride=(2,2))
l = ConvolutionOver2DAxisLayer(l, num_filters=40, filter_size=(3, 3),
axis=(2,3), channel=1,
W=lasagne.init.Orthogonal(),
b=lasagne.init.Constant(0.1),
nonlinearity=lasagne.nonlinearities.identity
)
l = BatchNormLayer(l, gamma=None)
l = lasagne.layers.NonlinearityLayer(l, nonlinearity=lasagne.nonlinearities.rectify)
l = MaxPoolOver2DAxisLayer(l, pool_size=(2, 2), axis=(2,3), stride=(2,2))
l_systole = lasagne.layers.DenseLayer(lasagne.layers.DropoutLayer(l),
num_units=600,
nonlinearity=lasagne.nonlinearities.softmax)
l_diastole = lasagne.layers.DenseLayer(lasagne.layers.DropoutLayer(l),
num_units=600,
nonlinearity=lasagne.nonlinearities.softmax)
return {
"inputs":{
"sliced:data:singleslice:difference": l0
},
"outputs": {
"systole:onehot": l_systole,
"diastole:onehot": l_diastole,
}
}
Example #12
| Source File: j0_mxnet1b.py From kaggle-heart with MIT License | 4 votes |
|
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:singleslice:difference:middle"]
l0 = InputLayer(input_size)
# add channel layer
# l0r = reshape(l0, (-1, 1, ) + input_size[1:])
# (batch, channel, time, x, y)
l = ConvolutionOver2DAxisLayer(l0, num_filters=40, filter_size=(5, 5),
axis=(2,3), channel=1,
W=lasagne.init.Orthogonal(),
b=lasagne.init.Constant(0.1),
nonlinearity=lasagne.nonlinearities.identity
)
l = BatchNormLayer(l, gamma=None)
l = lasagne.layers.NonlinearityLayer(l, nonlinearity=lasagne.nonlinearities.rectify)
l = MaxPoolOver2DAxisLayer(l, pool_size=(2, 2), axis=(2,3), stride=(2,2))
l = ConvolutionOver2DAxisLayer(l, num_filters=40, filter_size=(3, 3),
axis=(2,3), channel=1,
W=lasagne.init.Orthogonal(),
b=lasagne.init.Constant(0.1),
nonlinearity=lasagne.nonlinearities.identity
)
l = BatchNormLayer(l, gamma=None)
l = lasagne.layers.NonlinearityLayer(l, nonlinearity=lasagne.nonlinearities.rectify)
l = MaxPoolOver2DAxisLayer(l, pool_size=(2, 2), axis=(2,3), stride=(2,2))
l_systole = lasagne.layers.DenseLayer(lasagne.layers.DropoutLayer(l),
num_units=600,
nonlinearity=lasagne.nonlinearities.softmax)
l_diastole = lasagne.layers.DenseLayer(lasagne.layers.DropoutLayer(l),
num_units=600,
nonlinearity=lasagne.nonlinearities.softmax)
return {
"inputs":{
"sliced:data:singleslice:difference": l0
},
"outputs": {
"systole:onehot": l_systole,
"diastole:onehot": l_diastole,
}
}
Example #13
| Source File: j0_mxnet1c.py From kaggle-heart with MIT License | 4 votes |
|
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:singleslice:difference:middle"]
l0 = InputLayer(input_size)
# add channel layer
# l0r = reshape(l0, (-1, 1, ) + input_size[1:])
# (batch, channel, time, x, y)
l = ConvolutionOver2DAxisLayer(l0, num_filters=40, filter_size=(5, 5),
axis=(2,3), channel=1,
W=lasagne.init.Orthogonal(),
b=lasagne.init.Constant(0.1),
nonlinearity=lasagne.nonlinearities.identity
)
l = BatchNormLayer(l, gamma=None)
l = lasagne.layers.NonlinearityLayer(l, nonlinearity=lasagne.nonlinearities.rectify)
l = MaxPoolOver2DAxisLayer(l, pool_size=(2, 2), axis=(2,3), stride=(2,2))
l = ConvolutionOver2DAxisLayer(l, num_filters=40, filter_size=(3, 3),
axis=(2,3), channel=1,
W=lasagne.init.Orthogonal(),
b=lasagne.init.Constant(0.1),
nonlinearity=lasagne.nonlinearities.identity
)
l = BatchNormLayer(l, gamma=None)
l = lasagne.layers.NonlinearityLayer(l, nonlinearity=lasagne.nonlinearities.rectify)
l = MaxPoolOver2DAxisLayer(l, pool_size=(2, 2), axis=(2,3), stride=(2,2))
l_systole = lasagne.layers.DenseLayer(lasagne.layers.DropoutLayer(l),
num_units=600,
nonlinearity=lasagne.nonlinearities.softmax)
l_diastole = lasagne.layers.DenseLayer(lasagne.layers.DropoutLayer(l),
num_units=600,
nonlinearity=lasagne.nonlinearities.softmax)
return {
"inputs":{
"sliced:data:singleslice:difference": l0
},
"outputs": {
"systole:onehot": l_systole,
"diastole:onehot": l_diastole,
}
}
