def eval(self,
activations_iterator: ActivationsIterator,
verbose=False) -> MeasureResult:
running_means = [
RunningMeanWelford() for i in activations_iterator.layer_names()
]
for x, transformation_activations in tqdm(
activations_iterator.samples_first(), disable=not verbose):
for x_transformed, activations in transformation_activations:
for i, layer_activations in enumerate(activations):
if self.sign != 1:
layer_activations *= self.sign
activated: np.ndarray = (layer_activations >
self.thresholds[i]) * 1.0
# print(activated.shape,activated.min(),activated.max(),activated.dtype)
if np.any(activated < 0):
print(activated)
running_means[i].update_all(activated)
layers_l = [m.mean() for m in running_means]
return MeasureResult(layers_l, activations_iterator.layer_names(),
self)
def eval(self, activations_iterator: ActivationsIterator):
self.g = GlobalFiringRateNormalMeasure(self.alpha, self.sign)
g_result = self.g.eval(activations_iterator)
self.thresholds = g_result.extra_values["thresholds"]
self.l = LocalFiringRateNormalMeasure(self.thresholds, self.sign)
l_result = self.l.eval(activations_iterator)
ratio = tm.divide_activations(l_result.layers, g_result.layers)
return MeasureResult(ratio, activations_iterator.layer_names(), self)
def eval(self,
activations_iterator: ActivationsIterator,
verbose=False) -> MeasureResult:
td_result = self.td.eval(activations_iterator, verbose)
sd_result = self.sd.eval(activations_iterator, verbose)
td_result = self.pre_normalization_transformation.apply(td_result)
sd_result = self.pre_normalization_transformation.apply(sd_result)
result = divide_activations(td_result.layers, sd_result.layers)
return MeasureResult(result, activations_iterator.layer_names(), self)
def eval(self,activations_iterator:ActivationsIterator):
print("calculating global")
self.g = GlobalFiringRateMeasure(self.activations_percentage,self.sign)
g_result = self.g.eval(activations_iterator)
print("calculating thresholds")
self.thresholds = self.g.get_thresholds()
print("calculating local")
self.l = LocalFiringRateMeasure(self.thresholds,self.sign)
l_result = self.l.eval(activations_iterator)
ratio = divide_activations(l_result.layers,g_result.layers)
return MeasureResult(ratio, activations_iterator.layer_names(), self)
def eval(self, activations_iterator: ActivationsIterator, verbose=False):
self.g = GoodfellowNormalGlobalInvariance(self.alpha, self.sign)
g_result = self.g.eval(activations_iterator, verbose)
thresholds = g_result.extra_values[
GoodfellowNormalGlobalInvariance.thresholds_key]
self.l = GoodfellowNormalLocalInvariance(thresholds, self.sign)
l_result = self.l.eval(activations_iterator, verbose)
ratio = divide_activations(l_result.layers, g_result.layers)
extra = {self.g_key: g_result, self.l_key: l_result}
return MeasureResult(ratio,
activations_iterator.layer_names(),
self,
extra_values=extra)
def eval(self,
activations_iterator: ActivationsIterator,
verbose=False) -> MeasureResult:
running_means = [
RunningMeanAndVarianceWelford()
for i in activations_iterator.layer_names()
]
for transformation, samples_activations_iterator in tqdm(
activations_iterator.transformations_first(),
disable=not verbose):
for x, batch_activations in samples_activations_iterator:
for j, activations in enumerate(batch_activations):
if self.sign != 1: activations *= self.sign
running_means[j].update_all(activations)
stds = [running_mean.std() for running_mean in running_means]
means = [running_mean.mean() for running_mean in running_means]
original_shapes = [mean.shape for mean in means]
means = [mean.reshape(mean.size) for mean in means]
stds = [std.reshape(std.size) for std in stds]
# calculate the threshold values (approximately)
thresholds = [np.zeros(mean.size) for mean in means]
for i, (mean, std) in enumerate(zip(means, stds)):
for j, (mu, sigma) in enumerate(zip(mean, std)):
if sigma > 0:
t = norm.ppf(self.alpha, loc=mu, scale=sigma)
else:
t = mu
thresholds[i][j] = t
#thresholds = mean+2*std
thresholds = [
threshold.reshape(original_shape)
for threshold, original_shape in zip(thresholds, original_shapes)
]
# set g(i) equal to the activations_percentage
layers_g = [
np.zeros_like(threshold) + (1 - self.alpha)
for threshold in thresholds
]
return MeasureResult(layers_g,
activations_iterator.layer_names(),
self,
extra_values={self.thresholds_key: thresholds})
def eval(self,
activations_iterator: ActivationsIterator,
verbose=False) -> MeasureResult:
transformation_result = self.transformation_measure.eval(
activations_iterator, verbose)
sample_result = self.sample_measure.eval(activations_iterator, verbose)
result = divide_activations(transformation_result.layers,
sample_result.layers)
extra_values = {
self.transformation_key: transformation_result,
self.sample_key: sample_result,
}
return MeasureResult(result,
transformation_result.layer_names,
self,
extra_values=extra_values)
def eval(self,
activations_iterator: ActivationsIterator,
verbose=False) -> MeasureResult:
layer_names = activations_iterator.layer_names()
n_layers = len(layer_names)
mean_running = [RunningMeanWelford() for i in range(n_layers)]
for transformation, transformation_activations in activations_iterator.transformations_first(
):
# calculate the variance of all samples for this transformation
for x, batch_activations in transformation_activations:
for j, layer_activations in enumerate(batch_activations):
layer_measure = self.distance_aggregation.apply(
layer_activations)
mean_running[j].update(layer_measure)
# calculate the final mean over all transformations (and layers)
mean_variances = [b.mean() for b in mean_running]
return MeasureResult(mean_variances, layer_names, self)
def eval(self,
activations_iterator: ActivationsIterator,
verbose=False) -> MeasureResult:
layer_names = activations_iterator.layer_names()
n_intermediates = len(layer_names)
mean_running = [RunningMeanWelford() for i in range(n_intermediates)]
for x, transformation_activations_iterator in activations_iterator.samples_first(
):
# transformation_activations_iterator can iterate over all transforms
for x_transformed, activations in transformation_activations_iterator:
for j, layer_activations in enumerate(activations):
# calculate the distance aggregation only for this batch
layer_measure = self.distance_aggregation.apply(
layer_activations)
# update the mean over all transformation
mean_running[j].update(layer_measure)
# calculate the final mean over all samples (and layers)
mean_variances = [b.mean() for b in mean_running]
return MeasureResult(mean_variances, layer_names, self)
def eval(self, activations_iterator: ActivationsIterator) -> MeasureResult:
layer_names = activations_iterator.layer_names()
n_intermediates = len(layer_names)
layer_measures = [
self.layer_measure_generator(i, n)
for i, n in enumerate(layer_names)
]
for r in layer_measures:
r.on_begin()
for activations, x_transformed in activations_iterator.samples_first():
for r in layer_measures:
r.on_begin_iteration()
# activations has the activations for all the transformations
for j, layer_activations in enumerate(activations):
layer_measures[j].update_layer(layer_activations)
results = [r.get_final_result() for r in layer_measures]
return MeasureResult(results, layer_names, self)
def eval(self,
activations_iterator: ActivationsIterator,
verbose=False) -> MeasureResult:
sample_result = self.sv.eval(activations_iterator)
transformation_result = self.tv.eval(activations_iterator)
# TODO REFACTOR NEW layer_transformation.py
transformation_result = self.pre_normalization_transformation.apply(
transformation_result)
sample_result = self.pre_normalization_transformation.apply(
sample_result)
extra_values = {
self.transformation_key: transformation_result,
self.sample_key: sample_result,
}
result = divide_activations(transformation_result.layers,
sample_result.layers)
return MeasureResult(result, transformation_result.layer_names, self,
extra_values)
def eval(self,
activations_iterator: ActivationsIterator,
verbose=False) -> MeasureResult:
activations_iterator: ActivationsIterator = activations_iterator.get_inverted_activations_iterator(
)
ts = list(map(str, (activations_iterator.get_transformations())))
mean_variances_running = None
for transformation, samples_activations_iterator in activations_iterator.transformations_first(
):
samples_variances_running = None
# calculate the variance of all samples for this transformation
for x, batch_activations in samples_activations_iterator:
if mean_variances_running is None:
n_layers = len(batch_activations)
mean_variances_running = [
RunningMeanWelford() for i in range(n_layers)
]
if samples_variances_running is None:
n_layers = len(batch_activations)
samples_variances_running = [
RunningMeanAndVarianceWelford()
for i in range(n_layers)
]
for j, layer_activations in enumerate(batch_activations):
samples_variances_running[j].update_all(layer_activations)
# update the mean over all transformation (and layers)
for layer_mean_variances_running, layer_samples_variance_running in zip(
mean_variances_running, samples_variances_running):
layer_mean_variances_running.update(
layer_samples_variance_running.std())
# calculate the final mean over all transformations (and layers)
mean_variances = [b.mean() for b in mean_variances_running]
return MeasureResult(mean_variances,
activations_iterator.layer_names(), self)
def plot_heatmap(m: MeasureResult, vmin=None, vmax=None):
for i, l in enumerate(m.layers):
d = len(l.shape)
if d > 1:
dims = tuple(range(1, d))
m.layers[i] = np.nanmean(l, axis=dims)
if vmax is None: vmax = get_limit(m, "max")
if vmin is None:
vmin = get_limit(m, "min")
if vmin > 0:
vmin = 0
n = len(m.layer_names)
f, axes = plt.subplots(1, n, dpi=150, squeeze=False)
mappable = None
for i, (activation, name) in enumerate(zip(m.layers, m.layer_names)):
ax = axes[0, i]
ax.axis("off")
activation = activation[:, np.newaxis]
mappable = ax.imshow(activation,
vmin=vmin,
vmax=vmax,
cmap='inferno',
aspect="auto")
if n < 40:
if len(name) > 7:
name = name[:6] + "."
ax.set_title(name, fontsize=4, rotation=45)
f.subplots_adjust(right=0.8)
cbar_ax = f.add_axes([0.85, 0.15, 0.05, 0.7])
cbar = f.colorbar(mappable, cax=cbar_ax, extend='max')
cbar.cmap.set_over('green')
cbar.cmap.set_bad(color='gray')
return f
def eval(self,
activations_iterator: ActivationsIterator,
verbose=False) -> MeasureResult:
activations_iterator = activations_iterator.get_inverted_activations_iterator(
)
mean_running = None
for x, transformation_activations_iterator in activations_iterator.samples_first(
):
# transformation_activations_iterator can iterate over all transforms
for x_transformed, activations in transformation_activations_iterator:
if mean_running is None:
mean_running = [
RunningMeanWelford() for i in range(len(activations))
]
for j, layer_activations in enumerate(activations):
layer_measure = self.distance_aggregation.apply(
layer_activations)
# update the mean over all transformation
mean_running[j].update(layer_measure)
# calculate the final mean over all samples (and layers)
means = [b.mean() for b in mean_running]
return MeasureResult(means, activations_iterator.layer_names(), self)
def eval(self,
activations_iterator: ActivationsIterator,
verbose=False) -> MeasureResult:
activations_iterator = activations_iterator.get_inverted_activations_iterator(
)
mean_running = None
for x, transformation_activations in activations_iterator.samples_first(
):
transformation_variances_running = None
#calculate the running mean/variance/std over all transformations of x
for x_transformed, activations in transformation_activations:
if mean_running is None:
n_layers = len(activations)
mean_running = [
RunningMeanWelford() for i in range(n_layers)
]
if transformation_variances_running is None:
n_layers = len(activations)
transformation_variances_running = [
RunningMeanAndVarianceWelford()
for i in range(n_layers)
]
for i, layer_activations in enumerate(activations):
# apply function to conv layers
# update the mean over all transformations for this sample
transformation_variances_running[i].update_all(
layer_activations)
# update the mean with the numpy sample of all transformations of x
for i, layer_variance in enumerate(
transformation_variances_running):
mean_running[i].update(layer_variance.std())
# calculate the final mean over all samples (for each layer)
mean_variances = [b.mean() for b in mean_running]
return MeasureResult(mean_variances,
activations_iterator.layer_names(), self)
def generate_result_from_layer_results(self,results,names):
return MeasureResult(results, names, self)
def generate_result_from_layer_results(self, results_tresholds, names):
results_tresholds, tresholds = zip(*results_tresholds)
return MeasureResult(results_tresholds,
names,
self,
extra_values={"thresholds": tresholds})
