def plot_pearson_coefficients(spikerates_batch,
activations_batch,
config,
path=None):
"""
Plot the Pearson correlation coefficients for each layer, averaged over one
mini batch.
Parameters
----------
spikerates_batch: list[tuple[np.array, str]]
Each entry in ``spikerates_batch`` contains a tuple
``(spikerates, label)`` for each layer of the network (for the first
batch only, and excluding ``Flatten`` layers).
``spikerates`` contains the average firing rates of all neurons in a
layer. It has the same shape as the original layer, e.g.
(batch_size, n_features, n_rows, n_cols) for a convolution layer.
``label`` is a string specifying both the layer type and the index,
e.g. ``'03Dense'``.
activations_batch: list[tuple[np.array, str]]
Contains the activations of a net. Same structure as
``spikerates_batch``.
config: configparser.ConfigParser
Settings.
path: Optional[str]
Where to save the output.
"""
from snntoolbox.utils.utils import extract_label
max_rate = 1. / config.getfloat('simulation', 'dt')
co = get_pearson_coefficients(spikerates_batch, activations_batch,
max_rate)
# Average over batch
corr = np.mean(co, axis=1)
std = np.std(co, axis=1)
labels = [sp[1] for sp in spikerates_batch]
if config.getboolean('output', 'use_simple_labels'):
labels = [extract_label(label)[1] for label in labels]
plt.figure()
plt.bar([i + 0.1 for i in range(len(corr))],
corr,
width=0.8,
yerr=std,
color=(0.8, 0.8, 0.8))
plt.ylim([0, 1])
plt.xlim([0, len(corr)])
plt.xticks([i + 0.5 for i in range(len(labels))], labels, rotation=90)
plt.tick_params(bottom=False)
plt.title('Correlation between ANN activations \n and SNN spikerates,\n ' +
'averaged over {} samples'.format(len(spikerates_batch[0][0])))
plt.ylabel('Pearson Correlation Coefficient')
if path is not None:
filename = 'Pearson'
plt.savefig(os.path.join(path, filename), bbox_inches='tight')
else:
plt.show()
plt.close()
def plot_layer_summaries(plot_vars, config, path=None, data_format=None):
"""Display or save a number of plots for a specific layer.
Parameters
----------
plot_vars: dict
Example items:
- spikerates: list[tuple[np.array, str]]
Each entry in ``spikerates`` contains a tuple ``(rates, label)``
for each layer of the network (for the first batch only, and
excluding ``Flatten`` layers).
``rates`` contains the average firing rates of all neurons in a
layer. It has the same shape as the original layer, e.g.
(n_features, n_rows, n_cols) for a convolution layer.
``label`` is a string specifying both the layer type and the index,
e.g. ``'03Dense'``.
- activations: list[tuple[np.array, str]]
Contains the activations of a net. Same structure as
``spikerates``.
- spiketrains: list[tuple[np.array, str]]
Each entry in ``spiketrains`` contains a tuple
``(spiketimes, label)`` for each layer of the network (for the
first batch only, and excluding ``Flatten`` layers).
``spiketimes`` is an array where the last index contains the spike
times of the specific neuron, and the first indices run over the
number of neurons in the layer: (n_chnls, n_rows, n_cols, duration)
``label`` is a string specifying both the layer type and the index,
e.g. ``'03Dense'``.
config: configparser.ConfigParser
Settings.
path: Optional[str]
If not ``None``, specifies where to save the resulting image. Else,
display plots without saving.
data_format: Optional[str]
One of 'channels_first' or 'channels_last'.
"""
from snntoolbox.utils.utils import extract_label
plot_keys = eval(config.get('output', 'plot_vars'))
if len(plot_vars.keys()) == 0:
return
num_layers = len(list(plot_vars.values())[0])
for i in range(num_layers):
label = list(plot_vars.values())[0][i][1]
name = extract_label(label)[1] \
if config.getboolean('output', 'use_simple_labels') else label
print("Plotting layer {}".format(label))
newpath = os.path.join(path, label)
if not os.path.exists(newpath):
os.makedirs(newpath)
if 'spiketrains' in plot_keys:
plot_spiketrains(plot_vars['spiketrains_n_l_t'][i],
config.getfloat('simulation', 'dt'), newpath,
data_format)
if 'spikerates' in plot_keys:
plot_layer_activity(plot_vars['spikerates_n_l'][i],
str('Spikerates'),
newpath,
data_format=data_format)
plot_hist(
{'Spikerates': plot_vars['spikerates_n_l'][i][0].flatten()},
'Spikerates', name, newpath)
if 'activations' in plot_keys:
plot_layer_activity(plot_vars['activations_n_l'][i],
str('Activations'),
newpath,
data_format=data_format)
if 'spikerates_n_l' in plot_vars and 'activations_n_l' in plot_vars:
plot_activations_minus_rates(plot_vars['activations_n_l'][i][0],
plot_vars['spikerates_n_l'][i][0],
name, newpath, data_format)
if 'correlation' in plot_keys:
plot_layer_correlation(
plot_vars['spikerates_n_l'][i][0].flatten(),
plot_vars['activations_n_l'][i][0].flatten(),
str('ANN-SNN correlations\n of layer ' + name), config,
newpath, False)
