def get_most_active_units_in_layer(Inputs,
layers,
layer_ind,
filter,
n_units=None,
unique=True,
abs_act=False):
"""Get most active (sorted) units in specific layer for inputs.
Inputs: Inputs to calculate unit activations with
layers: Complete list of network layers
layer_ind: Index in layers in which unit activation should be computed
filter: Specific filter(s) in which the units are. If None: All filters in layer
n_Units: Number of most active units. If None: all units sorted (default: None)
unique: If only the most active Unit for each input should be kept. (default: True)
abs_act: If absolute unit activity should be used. (default: False)
Returns:
Most active units (Nx4) Input|Filter|X|Y
"""
if layers is not list:
layers = lasagne.layers.get_all_layers(layers)
if filter == None:
filter = np.arange(layers[layer_ind].output_shape[1])
pred_fn = create_pred_fn(layers)
output = pred_fn(Inputs)
return get_most_active_units_in_layer_from_output(output,
layer_ind,
filter,
n_units=n_units,
unique=unique,
abs_act=abs_act)
def __init__(self,
ExtractorData,
layer_ind,
finalReshapeAux,
filter_batch_size=None):
self.layer_ind = layer_ind
self.model_tmp, self.layer_tmp = check_if_finalreshape_is_needed(
ExtractorData.model, layer_ind)
self.model_RF = receptive_field_build_deconv_layers(
self.model_tmp[self.layer_tmp],
self.model_tmp[1],
use_learned_W=False,
X_reshape=finalReshapeAux)
self.pred_fn = create_pred_fn(self.model_tmp[self.layer_tmp])
all_outputs = list()
if filter_batch_size is None:
filter_splits = 1
else:
filter_splits = len(ExtractorData.inputs) / filter_batch_size + 1
input_batches = np.array_split(np.arange(len(ExtractorData.inputs)),
filter_splits)
for batch in input_batches:
if len(batch) == 0:
break
tmp = self.pred_fn(list(ExtractorData.inputs[batch])).astype(
np.float16)
tmp[tmp < 0] = 0
all_outputs.extend(tmp)
self.outputs = np.asarray(all_outputs, dtype=np.float16)
def recompute_bnorm_layer_statistics(final_layer, dataset, iterator):
all_layers = lasagne.layers.get_all_layers(final_layer)
bnorm_layers = [
l for l in all_layers if l.__class__.__name__ == 'BatchNormLayer'
]
for bnorm_layer in bnorm_layers:
log.info("Compiling bnorm layer...")
this_layer_pred_fn = create_pred_fn(bnorm_layer)
log.info("Predictions for bnorm layer...")
outs = [
this_layer_pred_fn(b[0])
for b in iterator.get_batches(dataset, shuffle=False)
]
outs = np.concatenate(outs)
outs_before_transform = (
(outs - bnorm_layer.beta.get_value()[None, :, None, None]) /
bnorm_layer.gamma.get_value()[None, :, None, None])
outs_before_transform = (
(outs_before_transform /
bnorm_layer.inv_std.get_value()[None, :, None, None]) +
bnorm_layer.mean.get_value()[None, :, None, None])
mean_this_layer = np.mean(outs_before_transform, axis=(0, 2, 3))
stds_this_layer = np.std(outs_before_transform, axis=(0, 2, 3))
bnorm_layer.mean.set_value(mean_this_layer)
bnorm_layer.inv_std.set_value(1.0 / stds_this_layer)
def compute_trial_acts(model, i_layer, iterator, train_set):
"""Compute activations per trial per sample for given layer of the model.
Parameters
----------
model: Lasagne layer
Final layer of the model.
i_layer: int
Index of layer to compute activations for.
iterator: DatasetIterator
Iterator to get batches from.
train_set: Dataset (Cnt)
Dataset to use.
Returns
-------
trial_acts: 3darray of float
Activations per trial per sample. #trialx#channelx#sample
"""
# compute number of inputs per trial
i_trial_starts, i_trial_ends = compute_trial_start_end_samples(
train_set.y,
check_trial_lengths_equal=True,
input_time_length=iterator.input_time_length)
# +1 since trial ends is inclusive
n_trial_len = i_trial_ends[0] - i_trial_starts[0] + 1
n_inputs_per_trial = int(
np.ceil(n_trial_len / float(iterator.n_sample_preds)))
log.info("Create theano function...")
all_layers = lasagne.layers.get_all_layers(model)
all_out_fn = create_pred_fn(all_layers[i_layer])
assert (iterator.input_time_length == get_input_time_length(model))
assert (iterator.n_sample_preds == get_n_sample_preds(model))
log.info("Compute activations...")
all_outs_per_batch = [
all_out_fn(batch[0])
for batch in iterator.get_batches(train_set, False)
]
batch_sizes = [
len(batch[0]) for batch in iterator.get_batches(train_set, False)
]
all_outs_per_batch = np.array(all_outs_per_batch)
n_trials = len(i_trial_starts)
log.info("Transform to trial activations...")
trial_acts = get_trial_acts(all_outs_per_batch,
batch_sizes,
n_trials=n_trials,
n_inputs_per_trial=n_inputs_per_trial,
n_trial_len=n_trial_len,
n_sample_preds=iterator.n_sample_preds)
log.info("Done.")
return trial_acts
def load_exp_pred_fn(basename, after_softmax):
exp, model = load_exp_and_model(basename)
if not after_softmax:
# replace softmax by identity to get better correlations
assert (model.nonlinearity.func_name == 'softmax'
or model.nonlinearity.func_name == 'safe_softmax')
model.nonlinearity = identity
# load dataset
log.info("Load dataset")
exp.dataset.load()
log.info("Create prediction function...")
pred_fn = create_pred_fn(model)
log.info("Done.")
return exp, pred_fn
def compute_rand_preds_topo_corr(exp, rand_model, trial_env):
pred_fn = create_pred_fn(rand_model)
train_set = exp.dataset_provider.get_train_merged_valid_test(exp.dataset)['train']
batches = [b[0] for b in exp.iterator.get_batches(train_set, shuffle=False)]
all_batch_sizes = [len(b) for b in batches]
all_preds = [pred_fn(b) for b in batches]
preds_per_trial = compute_preds_per_trial(train_set.y, all_preds, all_batch_sizes,
exp.iterator.input_time_length)
preds_per_trial = np.array(preds_per_trial)
# transpose from trialxsamplesxclasses to trialsxclassesxsamples
# as compute topo corr expects like this
rand_topo_corrs = compute_topo_corrs(trial_env,
preds_per_trial.transpose(0,2,1))
return rand_topo_corrs
def compute_trial_acts(model, i_layer, iterator, train_set):
"""Compute activations per trial per sample for given layer of the model.
Parameters
----------
model: Lasagne layer
Final layer of the model.
i_layer: int
Index of layer to compute activations for.
iterator: DatasetIterator
Iterator to get batches from.
train_set: Dataset (Cnt)
Dataset to use.
Returns
-------
trial_acts: 3darray of float
Activations per trial per sample. #trialx#channelx#sample
"""
# compute number of inputs per trial
i_trial_starts, i_trial_ends = compute_trial_start_end_samples(
train_set.y, check_trial_lengths_equal=True,
input_time_length=iterator.input_time_length)
# +1 since trial ends is inclusive
n_trial_len = i_trial_ends[0] - i_trial_starts[0] + 1
n_inputs_per_trial = int(np.ceil(n_trial_len / float(iterator.n_sample_preds)))
log.info("Create theano function...")
all_layers = lasagne.layers.get_all_layers(model)
all_out_fn = create_pred_fn(all_layers[i_layer])
assert(iterator.input_time_length == get_input_time_length(model))
assert(iterator.n_sample_preds == get_n_sample_preds(model))
log.info("Compute activations...")
all_outs_per_batch = [all_out_fn(batch[0])
for batch in iterator.get_batches(train_set, False)]
batch_sizes = [len(batch[0]) for batch in iterator.get_batches(train_set, False)]
all_outs_per_batch = np.array(all_outs_per_batch)
n_trials = len(i_trial_starts)
log.info("Transform to trial activations...")
trial_acts = get_trial_acts(all_outs_per_batch,
batch_sizes, n_trials=n_trials,
n_inputs_per_trial=n_inputs_per_trial,
n_trial_len=n_trial_len,
n_sample_preds=iterator.n_sample_preds)
log.info("Done.")
return trial_acts
def compute_rand_preds_topo_corr(exp, rand_model, trial_env):
pred_fn = create_pred_fn(rand_model)
train_set = exp.dataset_provider.get_train_merged_valid_test(
exp.dataset)['train']
batches = [
b[0] for b in exp.iterator.get_batches(train_set, shuffle=False)
]
all_batch_sizes = [len(b) for b in batches]
all_preds = [pred_fn(b) for b in batches]
preds_per_trial = compute_preds_per_trial(train_set.y, all_preds,
all_batch_sizes,
exp.iterator.input_time_length)
preds_per_trial = np.array(preds_per_trial)
# transpose from trialxsamplesxclasses to trialsxclassesxsamples
# as compute topo corr expects like this
rand_topo_corrs = compute_topo_corrs(trial_env,
preds_per_trial.transpose(0, 2, 1))
return rand_topo_corrs
def compute_pred_target_labels_for_cnt_exp(exp, model):
exp.dataset.ensure_is_loaded()
test_set = exp.dataset_provider.get_train_merged_valid_test(
exp.dataset)['test']
all_batches = list(exp.iterator.get_batches(test_set, shuffle=False))
log.info("Compile prediction function...")
pred_fn = create_pred_fn(model)
log.info("Done.")
log.info("Computing predictions")
all_preds = []
for batch in all_batches:
all_preds.append(pred_fn(batch[0]))
log.info("Done")
# second monitor should be correct one, else you would have to loop to find it
monitor = exp.monitors[2]
assert monitor.__class__.__name__ == 'CntTrialMisclassMonitor'
all_batch_sizes = [len(b[0]) for b in all_batches]
pred_labels, target_labels = monitor.compute_pred_and_target_labels(
test_set, all_preds, all_batch_sizes)
return pred_labels, target_labels
def recompute_bnorm_layer_statistics(final_layer, dataset, iterator):
all_layers = lasagne.layers.get_all_layers(final_layer)
bnorm_layers = [l for l in all_layers
if l.__class__.__name__ == 'BatchNormLayer']
for bnorm_layer in bnorm_layers:
log.info("Compiling bnorm layer...")
this_layer_pred_fn = create_pred_fn(bnorm_layer)
log.info("Predictions for bnorm layer...")
outs = [this_layer_pred_fn(b[0]) for b in iterator.get_batches(dataset,
shuffle=False)]
outs = np.concatenate(outs)
outs_before_transform = ((outs -
bnorm_layer.beta.get_value()[None,:,None,None]) /
bnorm_layer.gamma.get_value()[None,:,None,None])
outs_before_transform = ((outs_before_transform /
bnorm_layer.inv_std.get_value()[None,:,None,None]) +
bnorm_layer.mean.get_value()[None,:,None,None])
mean_this_layer = np.mean(outs_before_transform, axis=(0,2,3))
stds_this_layer = np.std(outs_before_transform, axis=(0,2,3))
bnorm_layer.mean.set_value(mean_this_layer)
bnorm_layer.inv_std.set_value(1.0 / stds_this_layer)
def get_receptive_field_mask(Units, l_RF, combined_units=False):
"""Get receptive field of the specified units.
Only works for 4D layers
Units: Active units in input layer of l_RF (Nx4) Input|Filter|X|Y
l_RF: Receptive field layer (original input layer)
combined_units: Separate receptive fields for each unit or combined for all (default: False)
Returns:
RF_output: Activation of units in the receptive field layer.
Activation > 0: unit lies in receptive field
"""
bot_layer = l_RF
top_layer = lasagne.layers.get_all_layers(l_RF)[0]
assert (len(top_layer.shape) == 4 and len(bot_layer.output_shape)
== 4), "Currently only works for 4D tensors"
if Units.shape[1] == 4:
Units = Units[:, 1:]
n_Units = len(Units)
in_indcs = np.arange(n_Units)
if combined_units:
in_indcs = 0
In_Units = np.zeros(
(n_Units, top_layer.shape[1], top_layer.shape[2], top_layer.shape[3]),
dtype=np.float32)
In_Units[in_indcs, Units[:, 0], Units[:, 1], Units[:, 2]] = 1
assert np.array_equal(top_layer.shape[1:], In_Units.shape[1:]), "Weird"
pred_fn = create_pred_fn(bot_layer)
RF_output = pred_fn(In_Units)
return RF_output
