def find_optimal_samples_report(pretrained_model, dataset, folder_name):
report_file_name = f'{folder_name}/{global_vars.get("report")}.pdf'
if os.path.isfile(report_file_name):
return
eeg_chans = list(range(global_vars.get('eeg_chans')))
plot_dict = OrderedDict()
dataset = unify_dataset(dataset)
for layer_idx, layer in list(enumerate(pretrained_model.children()))[global_vars.get('layer_idx_cutoff'):]:
max_examples = get_max_examples_per_channel(dataset.X, layer_idx, pretrained_model)
for chan_idx, example_idx in enumerate(max_examples):
tf_data = []
for eeg_chan in eeg_chans:
tf_data.append(get_tf_data_efficient(dataset.X[example_idx][None, :, :], eeg_chan, 250))
max_value = np.max(np.array(tf_data))
class_str = ''
if layer_idx >= len(list(pretrained_model.children())) - 3:
class_str = f', class:{label_by_idx(chan_idx)}'
plot_dict[(layer_idx, chan_idx)] = tf_plot(tf_data,
f'TF plot of example {example_idx} for layer '
f'{layer_idx}, channel {chan_idx}{class_str}',max_value)
print(f'plot most activating TF for layer {layer_idx}, channel {chan_idx}')
img_paths = list(plot_dict.values())
story = []
story.append(Paragraph('<br />\n'.join([f'{x}:{y}' for x,y in pretrained_model._modules.items()]), style=styles["Normal"]))
for im in img_paths:
story.append(get_image(im))
create_pdf_from_story(report_file_name, story)
for im in img_paths:
os.remove(im)
def avg_class_tf_report(model, dataset, folder_name):
report_file_name = f'{folder_name}/{global_vars.get("report")}.pdf'
if os.path.isfile(report_file_name):
return
eeg_chans = list(range(global_vars.get('eeg_chans')))
dataset = unify_dataset(dataset)
class_examples = []
for class_idx in range(global_vars.get('n_classes')):
class_examples.append(dataset.X[np.where(dataset.y == class_idx)])
if global_vars.get('to_eeglab'):
tensor_to_eeglab(class_examples[-1], f'{folder_name}/avg_class_tf/{label_by_idx(class_idx)}.mat')
chan_data = np.zeros((global_vars.get('n_classes'), len(eeg_chans), global_vars.get('num_frex'), global_vars.get('input_height')))
for class_idx in range(global_vars.get('n_classes')):
for eeg_chan in eeg_chans:
chan_data[class_idx, eeg_chan] = get_tf_data_efficient(class_examples[class_idx], eeg_chan,
global_vars.get('frequency'), global_vars.get('num_frex'),
dB=global_vars.get('db_normalization'))
max_value = np.max(chan_data)
tf_plots = []
for class_idx in range(global_vars.get('n_classes')):
tf_plots.append(tf_plot(chan_data[class_idx], f'average TF for {label_by_idx(class_idx)}', max_value))
story = [get_image(tf) for tf in tf_plots]
create_pdf_from_story(report_file_name, story)
for tf in tf_plots:
os.remove(tf)
def neuron_importance_report(model, dataset, folder_name):
report_file_name = f'{folder_name}/{global_vars.get("report")}.pdf'
eeg_chans = list(range(global_vars.get('eeg_chans')))
tf_plots = []
test_examples = prepare_data_for_NN(dataset['test'].X)
for layer_idx, layer in list(enumerate(model.children()))[global_vars.get('layer_idx_cutoff'):]:
layer_output = get_intermediate_layer_value(model, test_examples, layer_idx)
neuron_cond = NeuronConductance(model, layer)
for filter_idx in range(layer.out_channels):
for class_idx in range(global_vars.get('n_classes')):
conductance_values = []
if layer_output.ndim >= 3:
tensor_len = layer_output.shape[2]
else:
tensor_len = 1
for len_idx in range(tensor_len):
conductance_values.append(neuron_cond.attribute(random.choices(test_examples, k=int(len(test_examples) *
global_vars.get('explainer_sampling_rate'))), neuron_index=(filter_idx, len_idx), target=class_idx))
conductance_values = np.mean(conductance_values, axis=0)
print
if global_vars.get('to_eeglab'):
tensor_to_eeglab(reconstruction,
f'{folder_name}/kernel_deconvolution/X_layer_{layer_idx}_filter_{filter_idx}_class_{label_by_idx(class_idx)}.mat')
if global_vars.get('plot'):
subj_tfs = []
for eeg_chan in eeg_chans:
if global_vars.get('plot_TF'):
subj_tfs.append(get_tf_data_efficient(reconstruction.cpu().detach().numpy(),
eeg_chan, global_vars.get('frequency'), global_vars.get('num_frex'), dB=True))
print(f'applied TF to layer {layer_idx}, class {class_idx}, channel {eeg_chan}')
else:
subj_tfs.append(get_fft(np.average(reconstruction.cpu().detach().numpy(), axis=0).squeeze()[eeg_chan], global_vars.get('frequency')))
if global_vars.get('deconvolution_by_class'):
class_title = label_by_idx(class_idx)
else:
class_title = 'all'
if global_vars.get('plot_TF'):
tf_plots.append(tf_plot(subj_tfs, f'kernel deconvolution for layer {layer_idx},'
f' filter {filter_idx}, class {class_title}'))
else:
tf_plots.append(fft_plot(subj_tfs, f'kernel deconvolution for layer {layer_idx},'
f' filter {filter_idx}, class {class_title}'))
if global_vars.get('plot'):
create_pdf(report_file_name, tf_plots)
for im in tf_plots:
os.remove(im)
def gradient_ascent_report(pretrained_model, dataset, folder_name):
report_file_name = f'{folder_name}/{global_vars.get("report")}_{global_vars.get("gradient_ascent_steps")}_steps.pdf'
if os.path.isfile(report_file_name):
return
eeg_chans = list(range(global_vars.get('eeg_chans')))
plot_dict = OrderedDict()
plot_imgs = OrderedDict()
for layer_idx, layer in list(enumerate(list(pretrained_model.children())))[global_vars.get('layer_idx_cutoff'):]:
max_examples = create_max_examples_per_channel(layer_idx, pretrained_model, steps=global_vars.get('gradient_ascent_steps'))
max_value = 0
for chan_idx, example in enumerate(max_examples):
for eeg_chan in eeg_chans:
if global_vars.get('plot_TF'):
plot_dict[(layer_idx, chan_idx, eeg_chan)] = get_tf_data_efficient(example, eeg_chan, global_vars.get('frequency'), global_vars.get('num_frex'), dB=True)
max_value = max(max_value, np.max(plot_dict[(layer_idx, chan_idx, eeg_chan)]))
else:
plot_dict[(layer_idx, chan_idx, eeg_chan)] = get_fft(example.squeeze()[eeg_chan], global_vars.get('frequency'))
class_str = ''
for chan_idx, example in enumerate(max_examples):
if layer_idx >= len(list(pretrained_model.children())) - 3:
class_str = f', class:{label_by_idx(chan_idx)}'
if global_vars.get('plot_TF'):
plot_imgs[(layer_idx, chan_idx)] = tf_plot([plot_dict[(layer_idx, chan_idx, c)] for c in eeg_chans],
f'TF plot of optimal example for layer {layer_idx},'
f' channel {chan_idx}{class_str}')
else:
plot_imgs[(layer_idx, chan_idx)] = fft_plot([plot_dict[(layer_idx, chan_idx, c)] for c in eeg_chans],
f'FFT plot of optimal example for layer {layer_idx},'
f' channel {chan_idx}{class_str}')
print(f'plot gradient ascent TF for layer {layer_idx}, channel {chan_idx}')
story = []
img_paths = list(plot_imgs.values())
styles = getSampleStyleSheet()
story.append(
Paragraph('<br />\n'.join([f'{x}:{y}' for x, y in pretrained_model._modules.items()]), style=styles["Normal"]))
for im in img_paths:
story.append(get_image(im))
create_pdf_from_story(report_file_name, story)
for im in img_paths:
os.remove(im)
def perturbation_report(model, dataset, folder_name):
report_file_name = f'{folder_name}/{global_vars.get("report")}_{global_vars.get("band_filter").__name__}.pdf'
if os.path.isfile(report_file_name):
return
eeg_chans = list(range(get_dummy_input().shape[1]))
tf_plots = []
dataset = unify_dataset(dataset)
for frequency in range(global_vars.get("low_freq"), global_vars.get("high_freq") + 1):
single_subj_dataset = deepcopy(dataset)
perturbed_data = global_vars.get('band_filter')(single_subj_dataset.X,
max(1, frequency - 1), frequency + 1, global_vars.get('frequency'))
if global_vars.get('to_matlab'):
tensor_to_eeglab(perturbed_data, f'{folder_name}/perturbation_report/frequency_{frequency}_'
f'{global_vars.get("band_filter")}.mat')
single_subj_dataset.X = perturbed_data
subj_tfs = []
for eeg_chan in eeg_chans:
subj_tfs.append(get_tf_data_efficient(single_subj_dataset.X, eeg_chan, global_vars.get('frequency')))
tf_plots.append(tf_plot(subj_tfs, f'average TF for subject {global_vars.get("subject_id")},'
f' frequency {frequency}, {global_vars.get("band_filter").__name__}'))
story = [get_image(tf) for tf in tf_plots]
create_pdf_from_story(report_file_name, story)
for tf in tf_plots:
os.remove(tf)
def kernel_deconvolution_report(model, dataset, folder_name):
by_class_str = ''
if global_vars.get('deconvolution_by_class'):
by_class_str = '_by_class'
report_file_name = f'{folder_name}/{global_vars.get("report")}{by_class_str}.pdf'
if os.path.isfile(report_file_name):
return
if os.path.exists(f'{report_file_name[:-4]}.txt'):
os.remove(f'{report_file_name[:-4]}.txt')
conv_deconv = ConvDeconvNet(model)
eeg_chans = list(range(global_vars.get('eeg_chans')))
tf_plots = []
class_examples = []
if global_vars.get('deconvolution_by_class'):
for class_idx in range(global_vars.get('n_classes')):
all_class_examples = dataset['train'].X[np.where(dataset['train'].y == class_idx)]
class_examples.append(get_top_n_class_examples(all_class_examples, class_idx, model, int(len(all_class_examples) * global_vars.get('deconvolution_sampling_rate'))))
else:
class_examples.append(np.random.choice(dataset['train'].X, int(dataset['train'].X.shape[0] * global_vars.get('deconvolution_sampling_rate')) , replace=False))
for layer_idx, layer in list(enumerate(model.children()))[global_vars.get('layer_idx_cutoff'):]:
if type(layer) == nn.Conv2d:
for filter_idx in range(layer.out_channels):
for class_idx, examples in enumerate(class_examples):
X = prepare_data_for_NN(examples)
if global_vars.get('avg_deconv'):
X = torch.mean(X, axis=0)[None, :, :, :]
reconstruction = conv_deconv.forward(X, layer_idx, filter_idx)
dist_dict_original = get_class_distribution(model, X)
dist_dict_deconv = get_class_distribution(model, reconstruction)
for key in dist_dict_original.keys():
try:
orig_count = dist_dict_original[key]
except KeyError:
orig_count = 0
try:
deconv_count = dist_dict_deconv[key]
except KeyError:
deconv_count = 0
global_vars.get('sacred_ex').log_scalar(f'layer_{layer_idx}_class_{class_idx}_original',
orig_count, filter_idx)
global_vars.get('sacred_ex').log_scalar(f'layer_{layer_idx}_class_{class_idx}_deconv',
deconv_count, filter_idx)
if global_vars.get('to_eeglab'):
tensor_to_eeglab(reconstruction,
f'{folder_name}/kernel_deconvolution/X_layer_{layer_idx}_filter_{filter_idx}_class_{label_by_idx(class_idx)}.mat')
if global_vars.get('plot'):
subj_tfs = []
for eeg_chan in eeg_chans:
if global_vars.get('plot_TF'):
subj_tfs.append(get_tf_data_efficient(reconstruction.cpu().detach().numpy(),
eeg_chan, global_vars.get('frequency'), global_vars.get('num_frex'), dB=True))
print(f'applied TF to layer {layer_idx}, class {class_idx}, channel {eeg_chan}')
else:
subj_tfs.append(get_fft(np.average(reconstruction.cpu().detach().numpy(), axis=0).squeeze()[eeg_chan], global_vars.get('frequency')))
if global_vars.get('deconvolution_by_class'):
class_title = label_by_idx(class_idx)
else:
class_title = 'all'
if global_vars.get('plot_TF'):
tf_plots.append(tf_plot(subj_tfs, f'kernel deconvolution for layer {layer_idx},'
f' filter {filter_idx}, class {class_title}'))
else:
tf_plots.append(fft_plot(subj_tfs, f'kernel deconvolution for layer {layer_idx},'
f' filter {filter_idx}, class {class_title}'))
if global_vars.get('plot'):
create_pdf(report_file_name, tf_plots)
for im in tf_plots:
os.remove(im)