def _invert_GlobalPoolLayer(self, layer, feeder):
assert isinstance(layer, L.GlobalPoolLayer)
assert layer.pool_function == T.mean
assert len(L.get_output_shape(layer.input_layer)) == 4
target_shape = L.get_output_shape(feeder)+(1,1)
if target_shape[0] is None:
target_shape = (-1,) + target_shape[1:]
feeder = L.ReshapeLayer(feeder, target_shape)
upscaling = L.get_output_shape(layer.input_layer)[2:]
feeder = L.Upscale2DLayer(feeder, upscaling)
def expression(x):
return x / np.prod(upscaling).astype(theano.config.floatX)
feeder = L.ExpressionLayer(feeder, expression)
return feeder
python类ExpressionLayer()的实例源码
def setup_transform_net(self, input_var=None):
transform_net = InputLayer(shape=self.shape, input_var=input_var)
transform_net = style_conv_block(transform_net, self.num_styles, 32, 9, 1)
transform_net = style_conv_block(transform_net, self.num_styles, 64, 3, 2)
transform_net = style_conv_block(transform_net, self.num_styles, 128, 3, 2)
for _ in range(5):
transform_net = residual_block(transform_net, self.num_styles)
transform_net = nn_upsample(transform_net, self.num_styles)
transform_net = nn_upsample(transform_net, self.num_styles)
if self.net_type == 0:
transform_net = style_conv_block(transform_net, self.num_styles, 3, 9, 1, tanh)
transform_net = ExpressionLayer(transform_net, lambda X: 150.*X, output_shape=None)
elif self.net_type == 1:
transform_net = style_conv_block(transform_net, self.num_styles, 3, 9, 1, sigmoid)
self.network['transform_net'] = transform_net
def build_multi_dssm(input_var=None, num_samples=None, num_entries=6, num_ngrams=42**3, num_hid1=300, num_hid2=300, num_out=128):
"""Builds a DSSM structure in a Lasagne/Theano way.
The built DSSM is the neural network that computes the projection of only one paper.
The input ``input_var`` should have two dimensions: (``num_samples * num_entries``, ``num_ngrams``).
The output is then computed in a batch way: one paper at a time, but all papers from the same sample in the dataset are grouped
(cited papers, citing papers and ``num_entries - 2`` irrelevant papers).
Args:
input_var (:class:`theano.tensor.TensorType` or None): symbolic input variable of the DSSM
num_samples (int): the number of samples in the batch input dataset (number of rows)
num_entries (int): the number of compared papers in the DSSM structure
num_ngrams (int): the size of the vocabulary
num_hid1 (int): the number of units in the first hidden layer
num_hid2 (int): the number of units in the second hidden layer
num_out (int): the number of units in the output layer
Returns:
:class:`lasagne.layers.Layer`: the output layer of the DSSM
"""
assert (num_entries > 2)
# Initialise input layer
if num_samples is None:
num_rows = None
else:
num_rows = num_samples * num_entries
l_in = layers.InputLayer(shape=(num_rows, num_ngrams), input_var=input_var)
# Initialise the hidden and output layers or the DSSM
l_hid1 = layers.DenseLayer(l_in, num_units=num_hid1, nonlinearity=nonlinearities.tanh, W=init.GlorotUniform())
l_hid2 = layers.DenseLayer(l_hid1, num_units=num_hid2, nonlinearity=nonlinearities.tanh, W=init.GlorotUniform())
l_out = layers.DenseLayer(l_hid2, num_units=num_out, nonlinearity=nonlinearities.tanh, W=init.GlorotUniform())
l_out = layers.ExpressionLayer(l_out, lambda X: X / X.norm(2), output_shape='auto')
return l_out
def _get_normalised_relevance_layer(self, layer, feeder):
def add_epsilon(Zs):
tmp = (T.cast(Zs >= 0, theano.config.floatX)*2.0 - 1.0)
return Zs + self.epsilon * tmp
if isinstance(layer, L.DenseLayer):
forward_layer = L.DenseLayer(layer.input_layer,
layer.num_units,
W=layer.W,
b=layer.b,
nonlinearity=None)
elif isinstance(layer, L.Conv2DLayer):
forward_layer = L.Conv2DLayer(layer.input_layer,
num_filters=layer.num_filters,
W=layer.W,
b=layer.b,
stride=layer.stride,
filter_size=layer.filter_size,
flip_filters=layer.flip_filters,
untie_biases=layer.untie_biases,
pad=layer.pad,
nonlinearity=None)
else:
raise NotImplementedError()
forward_layer = L.ExpressionLayer(forward_layer,
lambda x: 1.0 / add_epsilon(x))
feeder = L.ElemwiseMergeLayer([forward_layer, feeder],
merge_function=T.mul)
return feeder
def nn_upsample(upsample_in, num_styles=None, num_filters=None, filter_size=3, stride=1):
if num_filters == None:
num_filters = upsample_in.output_shape[1]
nn_network = ExpressionLayer(upsample_in, lambda X: X.repeat(2, 2).repeat(2, 3), output_shape='auto')
nn_network = style_conv_block(nn_network, num_styles, num_filters, filter_size, stride)
return nn_network
def refine_flow(net, weights):
net['flow6'] = flow(net['conv6_1'])
net['flow6_up'] = upsample(net['flow6'])
net['deconv5'] = leaky_deconv(net['conv6_1'], num_filters=512)
net['concat5'] = ConcatLayer([net['conv5_1'], net['deconv5'], net['flow6_up']])
net['flow5'] = flow(net['concat5'])
net['flow5_up'] = upsample(net['flow5'])
net['deconv4'] = leaky_deconv(net['concat5'], num_filters=256)
net['concat4'] = ConcatLayer([net['conv4_1'], net['deconv4'], net['flow5_up']])
net['flow4'] = flow(net['concat4'])
net['flow4_up'] = upsample(net['flow4'])
net['deconv3'] = leaky_deconv(net['concat4'], num_filters=128)
net['concat3'] = ConcatLayer([net['conv3_1'], net['deconv3'], net['flow4_up']])
net['flow3'] = flow(net['concat3'])
net['flow3_up'] = upsample(net['flow3'])
net['deconv2'] = leaky_deconv(net['concat3'], num_filters=64)
net['concat2'] = ConcatLayer([net['conv2'], net['deconv2'], net['flow3_up']])
net['flow2'] = flow(net['concat2'])
# TODO: What does this magic number mean? We reduced an image size only 4
# times, didn't we?
# https://github.com/liruoteng/FlowNet/blob/master/models/flownet/model_simple/deploy.tpl.prototxt#L869
net['eltwise4'] = ExpressionLayer(net['flow2'], lambda x: x * 20)
# Should be upsampled before 'flow1' to 384x512
net['resample4'] = BilinearUpscaleLayer(net['eltwise4'], 4)
net['flow1'] = flow(net['resample4'], filter_size=1, pad=0)
for layer_name in ['deconv5', 'deconv4', 'deconv3', 'deconv2']:
net[layer_name].W.set_value(weights[layer_name][0])
upsample_map = {
'flow6_up': 'upsample_flow6to5',
'flow5_up': 'upsample_flow5to4',
'flow4_up': 'upsample_flow4to3',
'flow3_up': 'upsample_flow3to2'
}
for layer_name in ['flow6_up', 'flow5_up', 'flow4_up', 'flow3_up']:
net[layer_name].W.set_value(weights[upsample_map[layer_name]][0])
flow_map = {
'flow6': 'Convolution1',
'flow5': 'Convolution2',
'flow4': 'Convolution3',
'flow3': 'Convolution4',
'flow2': 'Convolution5',
'flow1': 'Convolution6'
}
for layer_name in ['flow6', 'flow5', 'flow4', 'flow3', 'flow2', 'flow1']:
net[layer_name].W.set_value(weights[flow_map[layer_name]][0])
net[layer_name].b.set_value(weights[flow_map[layer_name]][1])
def build_model(weights):
net = dict()
# T.nnet.abstract_conv.bilinear_upsampling doesn't work properly if not to
# specify a batch size
batch_size = 1
net['input_1'] = InputLayer([batch_size, 3, 384, 512])
net['input_2'] = InputLayer([batch_size, 3, 384, 512])
net['conv1'] = leaky_conv(
net['input_1'], num_filters=64, filter_size=7, stride=2)
net['conv1b'] = leaky_conv(
net['input_2'], num_filters=64, filter_size=7, stride=2,
W=net['conv1'].W, b=net['conv1'].b)
net['conv2'] = leaky_conv(
net['conv1'], num_filters=128, filter_size=5, stride=2)
net['conv2b'] = leaky_conv(
net['conv1b'], num_filters=128, filter_size=5, stride=2,
W=net['conv2'].W, b=net['conv2'].b)
net['conv3'] = leaky_conv(
net['conv2'], num_filters=256, filter_size=5, stride=2)
net['conv3b'] = leaky_conv(
net['conv2b'], num_filters=256, filter_size=5, stride=2,
W=net['conv3'].W, b=net['conv3'].b)
net['corr'] = CorrelationLayer(net['conv3'], net['conv3b'])
net['corr'] = ExpressionLayer(net['corr'], leaky_rectify)
net['conv_redir'] = leaky_conv(
net['conv3'], num_filters=32, filter_size=1, stride=1, pad=0)
net['concat'] = ConcatLayer([net['conv_redir'], net['corr']])
net['conv3_1'] = leaky_conv(net['concat'], num_filters=256, filter_size=3, stride=1)
net['conv4'] = leaky_conv(net['conv3_1'], num_filters=512, filter_size=3, stride=2)
net['conv4_1'] = leaky_conv(net['conv4'], num_filters=512, filter_size=3, stride=1)
net['conv5'] = leaky_conv(net['conv4_1'], num_filters=512, filter_size=3, stride=2)
net['conv5_1'] = leaky_conv(net['conv5'], num_filters=512, filter_size=3, stride=1)
net['conv6'] = leaky_conv(net['conv5_1'], num_filters=1024, filter_size=3, stride=2)
net['conv6_1'] = leaky_conv(net['conv6'], num_filters=1024, filter_size=3, stride=1)
for layer_id in ['1', '2', '3', '_redir', '3_1', '4', '4_1', '5', '5_1', '6', '6_1']:
layer_name = 'conv' + layer_id
print(layer_name, net[layer_name].W.shape.eval(), weights[layer_name][0].shape)
print(layer_name, net[layer_name].b.shape.eval(), weights[layer_name][1].shape)
net[layer_name].W.set_value(weights[layer_name][0])
net[layer_name].b.set_value(weights[layer_name][1])
refine_flow(net, weights)
return net
