def crop_test(cropping, inputs, expected):
inputs = [theano.shared(x) for x in inputs]
outs = autocrop(inputs, cropping)
outs = [o.eval() for o in outs]
assert len(outs) == len(expected)
for o, e in zip(outs, expected):
assert_array_equal(o, e)
def crop_test(cropping, inputs, expected):
inputs = [theano.shared(x) for x in inputs]
outs = autocrop(inputs, cropping)
outs = [o.eval() for o in outs]
assert len(outs) == len(expected)
for o, e in zip(outs, expected):
assert_array_equal(o, e)
def setOutputs_abs(self):
from lasagne.layers.merge import autocrop
for s in self.streams:
outs = []
for l in self.layers:
outs.append(l.outputs[s])
self.outputs[s] = tt.concatenate(autocrop(outs, self.croppings),
axis=self.axis)
def get_output_for(self, inputs, **kwargs):
inputs = autocrop(inputs, self.cropping)
output = None
for input in inputs:
if output is not None:
output = self.merge_function(output, input)
else:
output = input
return output
def get_output_for(self,
inputs,
deterministic=False,
batch_norm_use_averages=None,
batch_norm_update_averages=None,
**kwargs):
input, features = autocrop(inputs,
cropping=(None, None, "center", "center"))
input_mean, input_inv_std = feature_statistics(input, features)
# 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
# Decide whether to update the stored averages
if batch_norm_update_averages is None:
batch_norm_update_averages = not deterministic
update_averages = batch_norm_update_averages
if update_averages:
# Trick: To update the stored statistics, we create memory-aliased
# clones of the stored statistics:
running_mean = theano.clone(self.mean, share_inputs=False)
running_inv_std = theano.clone(self.inv_std, share_inputs=False)
# set a default update for them:
running_mean.default_update = ((1 - self.alpha) * running_mean +
self.alpha * input_mean)
running_inv_std.default_update = (
(1 - self.alpha) * running_inv_std +
self.alpha * input_inv_std)
# and make sure they end up in the graph without participating in
# the computation (this way their default_update will be collected
# and applied, but the computation will be optimized away):
mean += 0 * running_mean
inv_std += 0 * running_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
gamma = 1 if self.gamma is None else self.gamma
mean = mean
inv_std = inv_std
# normalize x, m, mean, inv_std, gamma,beta
normalized = feature_normalization(input, features, mean, inv_std,
gamma, beta)
return normalized