def cond_erg_enc_net(_incoming, _cond, noise_sigma=0.05, drop_ratio_conv=0.1):
#_noise = L.GaussianNoiseLayer(_incoming, sigma=noise_sigma)
_drop1 = L.DropoutLayer(_incoming, p=drop_ratio_conv, rescale=True)
_drop1 = plu.concat_tc(_drop1, _cond)
_conv1 = batch_norm(
conv(_drop1,
num_filters=128,
filter_size=4,
stride=2,
pad=1,
W=I.Normal(0.02),
b=None,
nonlinearity=NL.LeakyRectify(0.02)))
_drop2 = L.DropoutLayer(_conv1, p=drop_ratio_conv, rescale=True)
_drop2 = plu.concat_tc(_drop2, _cond)
_emb = batch_norm(
conv(_drop2,
num_filters=256,
filter_size=4,
stride=2,
pad=1,
W=I.Normal(0.02),
b=None,
nonlinearity=NL.LeakyRectify(0.02)))
return _emb
def nonlinearity(name):
nonlinearities = {
'rectify': nl.rectify,
'relu': nl.rectify,
'lrelu': nl.LeakyRectify(0.01),
'vlrelu': nl.LeakyRectify(0.33),
'elu': nl.elu,
'softmax': nl.softmax,
'sigmoid': nl.sigmoid,
'identity': nl.identity
}
return nonlinearities[name]
def set_rec_net(num_filters,filtsize,superres = 1,nonlin = lnl.LeakyRectify(0.2), AR = False, n_rnn_units = 128, n_features = 13):
input_l = ll.InputLayer((None, None))
rec_nn = ll.DimshuffleLayer(input_l, (0, 'x', 1))
hevar = np.sqrt(np.sqrt(2/(1+0.2**2)))
if nonlin == lnl.tanh:
init = lasagne.init.GlorotUniform()
else:
init = lasagne.init.HeNormal(hevar)
for num,size in zip(num_filters,filtsize):
rec_nn = (ll.Conv1DLayer(rec_nn, num_filters = num, filter_size = size, stride =1, pad = 'same',
nonlinearity = nonlin, name='conv1', W = init))
if not AR:
prob_nn = (ll.Conv1DLayer(rec_nn, num_filters = superres,filter_size = 11,stride =1, pad = 'same',
nonlinearity=lnl.sigmoid,name='conv2', b = lasagne.init.Constant(-3.)))
prob_nn = ll.DimshuffleLayer(prob_nn,(0,2,1))
prob_nn = ll.FlattenLayer(prob_nn)
else:
prob_nn = (ll.Conv1DLayer(rec_nn, num_filters = n_features,filter_size = 11,stride =1, pad = 'same',
nonlinearity=nonlin,name='conv2'))
prob_nn = ll.DimshuffleLayer(prob_nn,(0,2,1))
return {'network':prob_nn,'input':input_l, 'superres':superres, 'n_features':n_features, 'rnn_units':n_rnn_units}
def build_discriminator(input_var=None,
nfilters=[64, 128, 256, 512],
input_channels=3):
###############################
# Build Network Configuration #
###############################
print('... Building the discriminator')
leaky = nonlinearities.LeakyRectify(0.2)
# Input of the network : shape = (batch_size, 3, 64, 64)
network = layers.InputLayer(shape=(None, input_channels, 64, 64),
input_var=input_var)
# Conv layer : shape = (batch_size, 64, 32, 32)
network = layers.Conv2DLayer(network,
num_filters=nfilters[0],
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=leaky)
# Conv layer : shape = (batch_size, 128, 16, 16)
network = layers.batch_norm(
lasagne.layers.Conv2DLayer(network,
num_filters=nfilters[1],
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=leaky))
# Conv layer : shape = (batch_size, 256, 8, 8)
network = layers.batch_norm(
lasagne.layers.Conv2DLayer(network,
num_filters=nfilters[2],
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=leaky))
# Conv layer : shape = (batch_size, 512, 4, 4)
network = layers.batch_norm(
lasagne.layers.Conv2DLayer(network,
num_filters=nfilters[3],
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=leaky))
# Flatten layer :shape = (batch_size, 8192)
network = lasagne.layers.FlattenLayer(network)
# Dense layer :shape = (batch_size, 1)
network = lasagne.layers.DenseLayer(
network, 1, nonlinearity=lasagne.nonlinearities.sigmoid)
return network
def init_discriminator(self, first_layer, input_var=None):
"""
Initialize the DCGAN discriminator network using lasagne
Returns the network
"""
lrelu = nonlinearities.LeakyRectify(0.2)
layers = []
l_in = lyr.InputLayer((None, 3, 64, 64), input_var)
layers.append(l_in)
l_1 = lyr.Conv2DLayer(incoming=l_in,
num_filters=first_layer,
filter_size=5,
stride=2,
pad=2,
nonlinearity=lrelu)
layers.append(l_1)
l_2 = lyr.batch_norm(
lyr.Conv2DLayer(incoming=l_1,
num_filters=first_layer * 2,
filter_size=5,
stride=2,
pad=2,
nonlinearity=lrelu))
layers.append(l_2)
l_3 = lyr.batch_norm(
lyr.Conv2DLayer(incoming=l_2,
num_filters=first_layer * 4,
filter_size=5,
stride=2,
pad=2,
nonlinearity=lrelu))
layers.append(l_3)
l_4 = lyr.batch_norm(
lyr.Conv2DLayer(incoming=l_3,
num_filters=first_layer * 8,
filter_size=5,
stride=2,
pad=2,
nonlinearity=lrelu))
l_4 = lyr.FlattenLayer(l_4)
layers.append(l_4)
l_out = lyr.DenseLayer(incoming=l_4,
num_units=1,
nonlinearity=nonlinearities.sigmoid)
layers.append(l_out)
if self.verbose:
for i, layer in enumerate(layers):
print 'dicriminator layer %s output shape:' % i, layer.output_shape
return l_out
def erg_enc_net(_input, _cond=None):
if _cond != None:
_input = plu.concat_tc(_input, _cond)
_conv1 = batch_norm(
conv(_input,
num_filters=64,
filter_size=4,
stride=2,
pad=1,
W=I.Normal(0.02),
b=None,
nonlinearity=NL.LeakyRectify(0.1)))
#
if _cond != None:
_conv1 = plu.concat_tc(_conv1, _cond)
_conv2 = batch_norm(
conv(_conv1,
num_filters=128,
filter_size=4,
stride=2,
pad=0,
W=I.Normal(0.02),
b=None,
nonlinearity=NL.LeakyRectify(0.1)))
#
if _cond != None:
_conv2 = plu.concat_tc(_conv2, _cond)
_emb = batch_norm(
conv(_conv2,
num_filters=256,
filter_size=3,
stride=1,
pad=0,
W=I.Normal(0.02),
b=None,
nonlinearity=NL.LeakyRectify(0.1)))
return _emb
def erg_dec_net(_emb, _cond):
if _cond != None:
_conv3 = plu.concat_tc(_emb, _cond)
else:
_conv3 = _emb
_deconv1 = batch_norm(
deconv(_conv3,
num_filters=128,
filter_size=3,
stride=1,
crop=0,
W=I.Normal(0.02),
b=None,
nonlinearity=NL.LeakyRectify(0.01)))
#
if _cond != None:
_deconv1 = plu.concat_tc(_deconv1, _cond)
_deconv2 = deconv(_deconv1,
num_filters=64,
filter_size=4,
stride=2,
crop=0,
W=I.Normal(0.02),
b=None,
nonlinearity=NL.LeakyRectify(0.01))
#
if _cond != None:
_deconv2 = plu.concat_tc(_deconv2, _cond)
_deconv3 = deconv(_deconv2,
num_filters=npc,
filter_size=4,
stride=2,
crop=1,
W=I.Normal(0.02),
b=None,
nonlinearity=None)
return _deconv3
def __init__(self,
incoming,
num_filters,
filter_size,
noise_std=0.01,
stride=(1, 1),
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.LeakyRectify(0.05),
flip_filters=True,
convolution=T.nnet.conv2d,
seed=12347,
**kwargs):
pad = 'same'
super(NoisyDiff2DLayer,
self).__init__(incoming, num_filters, filter_size, noise_std,
stride, pad, untie_biases, W, b, nonlinearity,
flip_filters, convolution, seed, **kwargs)
def __init__(self,
incoming,
num_units,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.LeakyRectify(0.1),
num_leading_axes=1,
normalization='global',
eps=1.0e-6,
**kwargs):
super(RestrictedDenseLayer,
self).__init__(incoming, num_units, W, b, nonlinearity,
num_leading_axes, **kwargs)
self.normalization = normalization
self.eps = eps
if normalization not in ['unit', 'global']:
raise ValueError("normalization must be one of ['unit', 'global']")
def cond_erg_dec_net(_emb, _cond):
_deconv2 = plu.concat_tc(_emb, _cond)
_deconv2 = deconv(_deconv2,
num_filters=128,
filter_size=4,
stride=2,
crop=1,
W=I.Normal(0.02),
b=I.Constant(0),
nonlinearity=NL.LeakyRectify(0.02))
_deconv1 = plu.concat_tc(_deconv2, _cond)
_deconv1 = deconv(_deconv1,
num_filters=npc,
filter_size=4,
stride=2,
crop=1,
W=I.Normal(0.02),
b=I.Constant(0),
nonlinearity=None)
return _deconv1
def __init__(self,
incoming,
num_filters,
filter_size,
noise_std=0.01,
stride=(1, 1),
pad=0,
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.LeakyRectify(0.05),
flip_filters=True,
convolution=T.nnet.conv2d,
seed=12347,
**kwargs):
super(NoisyConv2DLayer,
self).__init__(incoming, num_filters, filter_size, stride, pad,
untie_biases, W, b, nonlinearity, flip_filters,
convolution, **kwargs)
self.noise_std = noise_std
self.srng = MRG_RandomStreams(seed=seed)
)
nnet3 = NeuralNet(
layers=[
('input', layers.InputLayer),
('hidden1', layers.DenseLayer),
('dropout1', layers.DropoutLayer),
('hidden2', layers.DenseLayer),
('dropout2', layers.DropoutLayer),
('hidden3', layers.DenseLayer),
('output', layers.DenseLayer),
],
# layer parameters:
input_shape=(None, 93), # 96x96 input pixels per batch
hidden1_num_units=800, # number of units in hidden layer
hidden1_nonlinearity=nonlinearities.LeakyRectify(leakiness=0.1),
dropout1_p=0.5,
hidden2_num_units=800,
hidden2_nonlinearity=nonlinearities.LeakyRectify(leakiness=0.1),
dropout2_p=0.5,
hidden3_num_units=800,
#hidden5_nonlinearity=nonlinearities.rectify,
#dropout5_p=0.5,
output_nonlinearity=nonlinearities.
softmax, # output layer uses identity function
output_num_units=9, # 30 target values
objective=L2Regularization,
objective_alpha=1E-9,
eval_size=0.0,
dropout1_p=0.5,
#dense1_nonlinearity=sigmoid,
dense2_num_units=dense_list[2],
dropout2_p=0.5,
#dense2_nonlinearity=sigmoid,
#dense3_num_units=dense_list[3],
#dropout3_p=0.5,
#dense4_num_units=900,
#dropout4_p=0.5,
#dropout2_p=0.5,
#dense3_num_units=550,
#dropout3_p=0.4,
#dense4_num_units=512,
#dropout4_p=0.3,
#hidden4_nonlinearity=lasagne.nonlinearities.sigmoid,
dense0_nonlinearity=nonlin.LeakyRectify(
leakiness=leakness_list[0]),
dense1_nonlinearity=nonlin.LeakyRectify(
leakiness=leakness_list[1]),
dense2_nonlinearity=nonlin.LeakyRectify(
leakiness=leakness_list[2]),
#dense3_nonlinearity= nonlin.LeakyRectify(leakiness=leakness_list[3]),
#dense0_nonlinearity= nonlin.LeakyRectify(0.1),
#dense1_nonlinearity= nonlin.LeakyRectify(0.1),
#dense2_nonlinearity= nonlin.LeakyRectify(0.1),
output_num_units=1,
output_nonlinearity=sigmoid,
update=adagrad,
#update=adadelta,
#update=nesterov_momentum,
objective_loss_function=binary_crossentropy,
y_tensor_type=T.imatrix,
def set_rec_net(num_filters,
filtsize,
nonlin=lnl.LeakyRectify(0.2),
AR=False,
FB=False,
n_rnn_units=64,
n_features=13,
n_genparams=0,
p_sigma=None):
"""
:param num_filters: Number of filters in each layer for the convolutional network, also sets number of layers
:param filtsize: Size of the filters in each layer
:param nonlin: Nonlinearity used
These parameters are only relevant if a RNN is used to obtain a correlated posterior estimation
:param AR: Whether this network is used as the first stage of an auto-regressive network
:param FB: Whether the auto-regressive network uses a backwards running RNN
:param n_rnn_units: Number of units in the RNN
:param n_features: Number of features passed form the CNN to the RNN
:param n_genparams: Number of generative model parameters inferred by the recognition network
:param p_sigma: standard deviation of the prior on the inffered generative model parameter.
"""
input_l = ll.InputLayer((None, None))
rec_nn = ll.DimshuffleLayer(input_l, (0, 'x', 1))
hevar = np.sqrt(np.sqrt(2 / (1 + 0.2**2)))
convout_nonlin = nonlin
if n_features == 1: convout_nonlin = lnl.linear
if nonlin == lnl.tanh:
init = lasagne.init.GlorotUniform()
else:
init = lasagne.init.HeNormal(hevar)
for num, size in zip(num_filters, filtsize):
rec_nn = (ll.Conv1DLayer(rec_nn,
num_filters=num,
filter_size=size,
stride=1,
pad='same',
nonlinearity=nonlin,
name='conv_filter',
W=init))
if not AR:
prob_nn = (ll.Conv1DLayer(rec_nn,
num_filters=1,
filter_size=11,
stride=1,
pad='same',
nonlinearity=lnl.sigmoid,
name='conv_out',
b=lasagne.init.Constant(-3.)))
prob_nn = ll.DimshuffleLayer(prob_nn, (0, 2, 1))
prob_nn = ll.FlattenLayer(prob_nn)
else:
prob_nn = (ll.Conv1DLayer(rec_nn,
num_filters=n_features,
filter_size=11,
stride=1,
pad='same',
nonlinearity=convout_nonlin,
name='conv_out'))
prob_nn = ll.DimshuffleLayer(prob_nn, (0, 2, 1))
if n_features == 1: prob_nn = ll.FlattenLayer(prob_nn)
return {
'network': prob_nn,
'input': input_l,
'n_features': n_features,
'rnn_units': n_rnn_units,
'n_genparams': n_genparams,
'p_sigma': p_sigma,
'forw_backw': FB
}
from lasagne import layers, nonlinearities
import theano.tensor as T
__all__ = [
'take', 'minimum', 'maximum', 'concat', 'noise', 'nothing', 'dropout',
'dense', 'select', 'batch_norm', 'elementwise', 'elementwise_sum',
'elementwise_mean', 'flatten', 'feature_pool', 'nonlinearity'
]
get_common_nonlinearity = lambda f=None: nonlinearities.LeakyRectify(
0.1) if f is None else f
minimum = lambda: lambda incomings: layers.ElemwiseMergeLayer(
incomings, merge_function=T.minimum)
maximum = lambda: lambda incomings: layers.ElemwiseMergeLayer(
incomings, merge_function=T.maximum)
concat = lambda axis=1: lambda incomings: layers.ConcatLayer(incomings,
axis=axis)
noise = lambda sigma=0.1: lambda incoming: \
layers.GaussianNoiseLayer(incoming, sigma=sigma) if sigma is not None and sigma > 0 else incoming
nothing = lambda incoming: incoming
dense = lambda num_units, f=None: lambda incoming: \
layers.DenseLayer(incoming, num_units=num_units, nonlinearity=(nonlinearities.LeakyRectify(0.05) if f is None else f))
dropout = lambda p=0.1, rescale=True: lambda incoming: \
layers.DropoutLayer(incoming, p=p, rescale=rescale) if p is not None else incoming
def build_context_encoder(input_var=None,
nfilters=[64, 128, 256, 512, 3000, 512, 256, 128, 3],
input_channels=3):
###############################
# Build Network Configuration #
###############################
print('... Building the generator')
leaky = nonlinearities.LeakyRectify(0.2)
# Input of the network : shape = (batch_size, 3, 64, 64)
network = layers.InputLayer(shape=(None, input_channels, 64, 64),
input_var=input_var)
# Conv layer : shape = (batch_size, 64, 32, 32)
network = layers.Conv2DLayer(network,
num_filters=nfilters[0],
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=leaky)
# Conv layer : shape = (batch_size, 128, 16, 16)
network = layers.batch_norm(
lasagne.layers.Conv2DLayer(network,
num_filters=nfilters[1],
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=leaky))
# Conv layer : shape = (batch_size, 256, 8, 8)
network = layers.batch_norm(
lasagne.layers.Conv2DLayer(network,
num_filters=nfilters[2],
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=leaky))
# Conv layer : shape = (batch_size, 512, 4, 4)
network = layers.batch_norm(
lasagne.layers.Conv2DLayer(network,
num_filters=nfilters[3],
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=leaky))
# Conv layer : shape = (batch_size, 3000, 1, 1)
network = layers.batch_norm(
lasagne.layers.Conv2DLayer(network,
num_filters=nfilters[4],
filter_size=(4, 4),
stride=2,
nonlinearity=leaky))
# Tranposed conv layer : shape = (batch_size, 512, 4, 4)
network = layers.batch_norm(
layers.TransposedConv2DLayer(network,
num_filters=nfilters[5],
filter_size=(4, 4),
stride=(1, 1)))
# Tranposed conv layer : shape = (batch_size, 256, 8, 8)
network = layers.batch_norm(
layers.TransposedConv2DLayer(network,
num_filters=nfilters[6],
filter_size=(5, 5),
stride=(2, 2),
crop=2,
output_size=8))
# Tranposed conv layer : shape = (batch_size, 128, 16, 16)
network = layers.batch_norm(
layers.TransposedConv2DLayer(network,
num_filters=nfilters[7],
filter_size=(5, 5),
stride=(2, 2),
crop=2,
output_size=16))
# Tranposed conv layer : shape = (batch_size, 3, 32, 32)
network = layers.TransposedConv2DLayer(network,
num_filters=nfilters[8],
filter_size=5,
stride=2,
crop=2,
output_size=32,
nonlinearity=nonlinearities.sigmoid)
return network
def build_conv_d(batch_size,
img_size,
n_conv_layer=4,
gan_mode=None,
wf=1,
filter_size=5,
fixed_nchan=None,
d_nl=ln.LeakyRectify(.2),
end_conv_layer=ll.FlattenLayer,
d_bn=None,
d_dp=None,
d_recon_reg=0,
bre_loc_mode='',
**kwargs):
if d_bn is None:
def d_bn(x):
return x
if d_dp is None:
def d_dp(x):
return x
conv = ll.Conv2DLayer
nl_layer = ll.NonlinearityLayer
d_layers = OrderedDict([])
d_register = registery_factory(d_layers)
l_data = ll.InputLayer(shape=(None, 3, img_size, img_size))
n_channel = fixed_nchan if fixed_nchan is not None else int(
wf * _base_hidden_nf)
name = layer_bre_name(bre_loc_mode, 0, n_conv_layer)
l_h = d_register(
conv(l_data,
num_filters=n_channel,
filter_size=(filter_size, filter_size),
stride=1,
pad='same',
nonlinearity=None), name)
l_h = d_dp(d_register(nl_layer(l_h, nonlinearity=d_nl)))
for idx in xrange(1, n_conv_layer):
if fixed_nchan:
n_channel = fixed_nchan
else:
n_channel *= 2
print bre_loc_mode
name = layer_bre_name(bre_loc_mode, idx, n_conv_layer)
l_h = d_register(
conv(l_h,
num_filters=n_channel,
filter_size=(filter_size, filter_size),
stride=2,
pad='same',
nonlinearity=None), name)
l_h = d_dp(d_bn(d_register(nl_layer(l_h, nonlinearity=d_nl))))
l_h = d_register(end_conv_layer(l_h), 'l_h_feat')
l_out_d = critic_output_layer(l_h, gan_mode, register_func=d_register)
return l_out_d, l_data, d_layers
def makeDiscriminator(self, aNBatch, aX, aXShape, aY, aYSize):
#(D1)
yb = aY.dimshuffle(0, 1, 'x', 'x')
#(D2)
layer_X = ll.InputLayer(shape=aXShape, input_var=aX, name='lX')
layer_Y = ll.InputLayer(shape=(aNBatch, aYSize),
input_var=aY,
name='lY')
dis = self.conv_cond_concat(layer_X, yb, aYSize)
#(D3), (D4)
if self.IS_DIS_BIN:
dis = binary_net_ex.Conv2DLayer(
dis,
num_filters=NUM_DIS_FILTERS,
filter_size=(5, 5),
stride=(2, 2),
nonlinearity=ln.LeakyRectify(0.2), #TODO
pad=2,
binary=True,
stochastic=IS_STOCHASTIC,
H=H,
W_LR_scale=W_LR_scale)
else:
dis = ll.Conv2DLayer(dis,
num_filters=NUM_DIS_FILTERS,
filter_size=(5, 5),
stride=(2, 2),
nonlinearity=ln.LeakyRectify(0.2),
pad=2)
print 'D4:', dis.output_shape # (128, 64, 14, 14)
#(D5)
dis = self.conv_cond_concat(dis, yb, aYSize)
#(D6)
if self.IS_DIS_BIN:
dis = binary_net_ex.Conv2DLayer(dis,
num_filters=NUM_DIS_FILTERS * 2,
filter_size=(5, 5),
stride=(2, 2),
nonlinearity=None,
pad=2,
binary=True,
stochastic=IS_STOCHASTIC,
H=H,
W_LR_scale=W_LR_scale)
else:
dis = ll.Conv2DLayer(dis,
num_filters=NUM_DIS_FILTERS * 2,
filter_size=(5, 5),
stride=(2, 2),
nonlinearity=None,
pad=2)
print 'D6:', dis.output_shape # (128, 128, 7, 7)
dis = ll.BatchNormLayer(dis, epsilon=EPSILON, alpha=ALPHA)
dis = ll.NonlinearityLayer(dis,
nonlinearity=ln.LeakyRectify(0.2)) #TODO
#(D7)
dis = ll.FlattenLayer(dis, outdim=2)
print 'D7:', dis.output_shape # (128, 6272)
#(D8)
dis = ll.ConcatLayer([dis, layer_Y], axis=1)
#(D9)
if self.IS_DIS_BIN:
dis = binary_net_ex.DenseLayer(
dis,
num_units=NUM_DIS_FC_UNITS,
binary=True,
stochastic=IS_STOCHASTIC,
H=H,
W_LR_scale=W_LR_scale,
b=None, #No Bias
nonlinearity=None)
else:
dis = ll.DenseLayer(dis, num_units=NUM_DIS_FC_UNITS)
dis = ll.BatchNormLayer(dis, epsilon=EPSILON, alpha=ALPHA)
dis = ll.NonlinearityLayer(dis,
nonlinearity=ln.LeakyRectify(0.2)) #TODO
#(D10)
dis = ll.ConcatLayer([dis, layer_Y], axis=1)
#(D11) OUTPUT layer
dis = ll.DenseLayer(dis, num_units=1, nonlinearity=ln.sigmoid)
print 'D11:', dis.output_shape # (128, 1)
self.dis = dis
return dis, layer_X, layer_Y
def model_CENTSD_33conv(patch_size, batch_size, FAST_network=False, FAST_imgheight=None, FAST_imgwidth=None, nonlin_func='leaky'):
""" Describes the main network used in the PatchBatch paper """
if nonlin_func == 'leaky':
nonlin = nonlinearities.LeakyRectify(leaky_param)
elif nonlin_func == 'elu':
nonlin = nonlinearities.elu
else:
print 'Error! Unsupported non-linearity function'
return
if FAST_network:
l_in0 = layers.InputLayer(
shape=(1, 1, FAST_imgheight, FAST_imgwidth),name='l_in0')
else:
l_in0 = layers.InputLayer(
shape=(batch_size, in_channels, patch_size, patch_size),name='l_in0')
layer_params = {'conv_num_filters':32,
'conv_filter_size':(3,3),
'conv_border_mode':border_mode,
'conv_nonlinearity':nonlin,
'batch_norm':True,
'maxpool':True,
'maxpool_ds':(2,2)}
layer = layer_factory(in_layer=l_in0,layer_type='conv',**layer_params)
layer_params = {'conv_num_filters':64,
'conv_filter_size':(3,3),
'conv_border_mode':border_mode,
'conv_nonlinearity':nonlin,
'batch_norm':True,
'maxpool':True,
'maxpool_ds':(2,2)}
layer = layer_factory(in_layer=layer,layer_type='conv',**layer_params)
layer_params = {'conv_num_filters':128,
'conv_filter_size':(3,3),
'conv_border_mode':border_mode,
'conv_nonlinearity':nonlin,
'batch_norm':True,
'maxpool':True,
'maxpool_ds':(2,2)}
layer = layer_factory(in_layer=layer,layer_type='conv',**layer_params)
layer_params = {'conv_num_filters':256,
'conv_filter_size':(3,3),
'conv_border_mode':border_mode,
'conv_nonlinearity':nonlin,
'batch_norm':True,
'maxpool':True,
'maxpool_ds':(2,2)}
layer = layer_factory(in_layer=layer,layer_type='conv',**layer_params)
layer_params = {'conv_num_filters':512,
'conv_filter_size':(2,2),
'conv_border_mode':border_mode,
'conv_nonlinearity':nonlin,
'batch_norm':True,
'maxpool':False,
'maxpool_ds':(2,2)}
layer = layer_factory(in_layer=layer,layer_type='conv',**layer_params)
return layer
