def test_animated_hist(): ## set the Masterpath to the folder where your output is saved n_epochs = 19 masterpath = "/Users/clemens/Documents/Code/ModelClemens/output" ## set the subfolder to the Simulation you want to analyse subfolders = ["10_25-19_10_only_loc_1"] ## if more than the inital epoch is needed *1 needs to be run extensions = ["initial"] + [ "testing/epoch{}".format(n) for n in range(1, n_epochs) ] object_list = data.load_testing_stimuli_info( masterpath + "/" + subfolders[0]) # assuming all the subfolders have the same n_stimuli = np.sum(obj['count'] for obj in object_list) current_index = 0 object_indices = [] for obj in object_list: object_indices.append( list(range(current_index, current_index + obj['count']))) current_index += obj["count"] # info_neurons is just an array of the information from above. This makes it easier to run the functions and pass the information. # info_times same for times network_architecture = dict( num_exc_neurons_per_layer=64 * 64, num_inh_neurons_per_layer=32 * 32, num_layers=4, # total_per_layer = num_exc_neurons_per_layer + num_inh_neurons_per_layer, # total_network = total_per_layer * num_layers, # num_stimuli = 16 ) info_times = dict(length_of_stimulus=2.0, num_stimuli=n_stimuli, time_start=1.5, time_end=1.9) spikes = data.load_spikes_from_subfolders(masterpath, subfolders, extensions, False) start = timer() # rates_subfolders = firing.slow_calculate_rates_subfolder( # spikes, # network_architecture, # info_times) # print("Non multiprocessing version took {}".format(timer() - start)) start = timer() rates_subfolders = firing.calculate_rates_subfolder( spikes, network_architecture, info_times) print("Multiprocessing version took {}".format(timer() - start)) exc_information, inhibitory_information = info.single_cell_information_all_epochs( rates_subfolders[0], object_indices, 3) ani = spikeplot.plot_animated_histogram(exc_information) import matplotlib.pyplot as plt plt.show()
def test_mutual_and_single_cell_info(): ## set the Masterpath to the folder where your output is saved n_epochs = 188 masterpath = "/Users/clemens/Documents/Code/ModelClemens/output" ## set the subfolder to the Simulation you want to analyse subfolders = ["11_05-20_04_loc1_both"] ## if more than the inital epoch is needed *1 needs to be run extensions = ["initial"] # + ["testing/epoch180"] object_list = data.load_testing_stimuli_info( masterpath + "/" + subfolders[0]) # assuming all the subfolders have the same n_stimuli = np.sum(obj['count'] for obj in object_list) # info_neurons is just an array of the information from above. This makes it easier to run the functions and pass the information. # info_times same for times network_architecture = dict( num_exc_neurons_per_layer=64 * 64, num_inh_neurons_per_layer=32 * 32, num_layers=4, # total_per_layer = num_exc_neurons_per_layer + num_inh_neurons_per_layer, # total_network = total_per_layer * num_layers, # num_stimuli = 16 ) info_times = dict(length_of_stimulus=2.0, num_stimuli=n_stimuli, time_start=1.5, time_end=1.9) # objects_in_training = [ # object_list[0]['indices'] + object_list[1]['indices'] + object_list[2]['indices'] + object_list[3]['indices'], # object_list[4]['indices'] + object_list[5]['indices'] + object_list[6]['indices'] + object_list[7]['indices'], # ] # # These Objects were bound together in training with temporal trace. so it should have learned information about them. # print(objects_in_training) object_indices = [obj['indices'] for obj in object_list] spikes = data.load_spikes_from_subfolders(masterpath, subfolders, extensions, False) rates_subfolders = firing.calculate_rates_subfolder( spikes, network_architecture, info_times) exh_mutual_info, inh_mutual_info = info.firing_rates_to_mutual_information( rates_subfolders[0][0], object_indices, 3, calc_inhibitory=True) exc_single_cell, inh_single_cell = info.firing_rates_to_single_cell_information( rates_subfolders[0][0], object_indices, 3, calc_inhibitory=True) assert (np.all( np.isclose(exh_mutual_info[0], np.mean(exc_single_cell, axis=0)))) assert (np.all( np.isclose(inh_mutual_info[0], np.mean(inh_single_cell, axis=0))))
def test_single_cell_decoder(): path = "/Users/clemens/Documents/Code/ModelClemens/output" experiment = "12_27-18_57_all_no_trace" extension = "testing/epoch300" object_list = data.load_testing_stimuli_indices_from_wildcarts( path + "/" + experiment, ["***l", "***r"]) print(object_list) object_indices = [o['indices'] for o in object_list] print(object_indices) n_stimuli = np.sum([o['count'] for o in object_list]) label_for_classifier = np.zeros((2, n_stimuli), dtype=bool) for i, o in enumerate(object_list): label_for_classifier[i, o['indices']] = True label_for_classifier_from_data_loading = data.load_testing_stimuli_label_matrix( path + "/" + experiment, ["***l", "***r"]) assert (np.all( label_for_classifier == label_for_classifier_from_data_loading)) print(label_for_classifier) network_architecture = dict(num_exc_neurons_per_layer=64 * 64, num_inh_neurons_per_layer=32 * 32, num_layers=4) info_times = dict(length_of_stimulus=2.0, num_stimuli=n_stimuli, time_start=1.5, time_end=1.9) spikes = data.load_spikes_from_subfolders(path, [experiment], [extension], False) rates_subfolders = firing.calculate_rates_subfolder( spikes, network_architecture, info_times) exc_rates, inh_rates = helper.nested_list_of_stimuli_2_np( rates_subfolders[0][0]) dec = info.SingleCellDecoder() perf_train = dec.fit(exc_rates, label_for_classifier) perf_sumary = dec.get_performance_summary(exc_rates, label_for_classifier) perf_test = perf_sumary.accuracy() assert (np.all(perf_train == perf_test)) print(perf_train == perf_test) print("done")
def test_weighted_presynaptic_firing_rates(): path = "/Users/clemens/Documents/Code/ModelClemens/output/" subfolders = ["11_06-15_00_loc1_centered"] extensions = ["initial" ] + ["testing/epoch{}".format(e) for e in range(1, 30)] net, weights = data.load_weights_all_epochs(path + subfolders[0], range(1, 30)) object_list = data.load_testing_stimuli_info( path + subfolders[0]) # assuming all the subfolders have the same n_stimuli = np.sum(obj['count'] for obj in object_list) object_indices = [obj['indices'] for obj in object_list] network_architecture = dict(num_exc_neurons_per_layer=64 * 64, num_inh_neurons_per_layer=32 * 32, num_layers=4) info_times = dict(length_of_stimulus=2.0, num_stimuli=n_stimuli, time_start=1.5, time_end=1.9) spikes = data.load_spikes_from_subfolders(path, subfolders, extensions, False) rates_subfolders = firing.calculate_rates_subfolder( spikes, network_architecture, info_times) exc_rates, inh_rates = helper.nested_list_of_epochs_2_np( rates_subfolders[0]) mymask = synapses.Synapse_Mask(network_architecture, net) neuron_id = 5939 excitatory_mask = np.invert(mymask.inh_lateral()) overall_mask = excitatory_mask & (net.post.values == neuron_id) weighted_current = synapses.weighted_presynaptic_actvity( overall_mask, net=net, weights=weights, firing_rates=(exc_rates, inh_rates)) return weighted_current
def summary_for_experiment(name): exp_path = output_path + "/" + name overview_path = exp_path + "/" + overview_folder_name epoch_names = ["initial"] + data.get_epochs(exp_path) object_list = data.load_testing_stimuli_info(exp_path) n_stimuli = np.sum(obj['count'] for obj in object_list) object_indices = [obj['indices'] for obj in object_list] stimuli_names = data.load_testing_stimuli_names(exp_path) info_times["num_stimuli"] = n_stimuli spikes = data.load_spikes_from_subfolders(output_path, [name], epoch_names, False) rates_subfolders = firing.calculate_rates_subfolder( spikes, network_architecture, info_times) spikes = None exc_information, inh_information = info.single_cell_information_all_epochs( rates_subfolders[0], object_indices, 3) ### make and save plots os.mkdir(overview_path) info_dev_plot = spikeplot.plot_information_development(exc_information, mean_of_top_n=500, threshold=1) info_dev_plot.savefig(overview_path + "/performance_dev.png") for r in plot_fr_at: epoch_id = int(r * (len(epoch_names) - 1)) cur_epoch_fr_plot = spikeplot.plot_fr_ranked( rates_subfolders[0][epoch_id], stimuli_names, percentage_to_plot=0.5) epoch_name = epoch_names[epoch_id].split("/")[-1] make_pdf("{}/firing_rates_{}.pdf".format(overview_path, epoch_name), cur_epoch_fr_plot) return
def test_functional_freq_table(): ## set the Masterpath to the folder where your output is saved masterpath = "/Users/clemens/Documents/Code/ModelClemens/output" ## set the subfolder to the Simulation you want to analyse subfolders = ["2017:10:20-16:50:34_only_first_location_123_epochs"] ## if more than the inital epoch is needed *1 needs to be run extensions = ["testing/epoch5", "testing/epoch123"] # info_neurons is just an array of the information from above. This makes it easier to run the functions and pass the information. # info_times same for times network_architecture = dict( num_exc_neurons_per_layer=64 * 64, num_inh_neurons_per_layer=32 * 32, num_layers=4, # total_per_layer = num_exc_neurons_per_layer + num_inh_neurons_per_layer, # total_network = total_per_layer * num_layers, # num_stimuli = 16 ) info_times = dict(length_of_stimulus=2.0, num_stimuli=16, time_start=1.5, time_end=1.9) spikes = data.load_spikes_from_subfolders(masterpath, subfolders, extensions, False) rates_subfolders = firing.calculate_rates_subfolder( spikes, network_architecture, info_times) final_epoch_rates = rates_subfolders[0][1] objects = [[0, 1, 2, 3, 8, 9, 10, 11], [4, 5, 6, 7, 12, 13, 14, 15]] # each is presented twice exc_rates, inh_rates = helper.nested_list_of_stimuli_2_np( final_epoch_rates) freq_table = combine.response_freq_table(exc_rates, objects) single_cell_info = info.single_cell_information(freq_table) return single_cell_info
def test_single_cell_information(self): masterpath = "/Users/clemens/Documents/Code/ModelClemens/output" ## set the subfolder to the Simulation you want to analyse subfolders = ["10_26-18_14_short_test_loc1"] ## if more than the inital epoch is needed *1 needs to be run extensions = ["initial"] # info_neurons is just an array of the information from above. This makes it easier to run the functions and pass the information. # info_times same for times network_architecture = dict( num_exc_neurons_per_layer=64 * 64, num_inh_neurons_per_layer=32 * 32, num_layers=4, # total_per_layer = num_exc_neurons_per_layer + num_inh_neurons_per_layer, # total_network = total_per_layer * num_layers, # num_stimuli = 16 ) info_times = dict(length_of_stimulus=2.0, num_stimuli=16, time_start=1.5, time_end=1.9) n_bins = 3 spikes = data.load_spikes_from_subfolders(masterpath, subfolders, extensions, input_layer=False) firing_rates = firing.calculate_rates_subfolder( spikes, network_architecture, info_times) rates = firing_rates[0][0] exc_rates, inh_rates = helper.nested_list_of_stimuli_2_np(rates) objects = [[0, 1, 2, 3, 8, 9, 10, 11], [4, 5, 6, 7, 12, 13, 14, 15]] # each is presented twice start = timer() exc_table = combine.response_freq_table(exc_rates, objects, n_bins=n_bins) exc_info = info.single_cell_information(exc_table) final_new_info_l2 = exc_info[:, 2, :] # shape [2, n_neurons] for both objects all info in layer 2 print("New version of info calc took {}s".format(timer() - start)) ### calculating it the old way import InformationAnalysis as infoOld categories = np.zeros((56, 1)) categories[ 28:, 0] = 1 # simulating the fact that we have 2 objects -> stimuli with only one attribute, object_id 1 or 0 start = timer() digitized_firing_rates = firing.digitize_firing_rates_with_equispaced_bins( exc_rates, n_bins=n_bins) digitized_firing_rates_l2 = digitized_firing_rates[:, 2, :] freq_table_old = infoOld.frequency_table(digitized_firing_rates_l2, categories, list(range(n_bins))) final_old_info_l2 = infoOld.single_cell_information( freq_table_old, categories)[0] print("Old version of info calc took {}s".format(timer() - start)) assert (np.all(np.isclose(final_new_info_l2, final_old_info_l2)))