def make_rdm_and_mds_reg_hierarchy(name): model = utils.load_object(name, 1) # eg 'noise_test2' hidden = accuracy_test_reg_hierarchy(model) # Turn a list of tensors into a list of np vectors for i, tensor in enumerate(hidden): hidden[i] = tensor.numpy().reshape(-1) # Now cut that in two left_units = [vector[:len(hidden) / 2] for vector in hidden] right_units = [vector[len(hidden) / 2:] for vector in hidden] # Make the labels for the rdms labels = [] for i, sequence in enumerate(pnas2018task.seqs): for action in sequence[1:]: labels.append(str(i) + '_' + action) for side in [[left_units, "left units"], [right_units, "right_units"]]: rdm = analysis.rdm_spearman(side[0]) analysis.plot_rdm(rdm, labels, "Spearman rho matrix" + side[1]) #for i in range(4): # mdsy = analysis.mds(side[0][6*i:6*i+6]) # analysis.plot_mds_points(mdsy, range(len(mdsy)), labels=labels[6*i:6*i+6]) mdsy = analysis.mds(side[0]) for i, style in enumerate(['ro-', 'b|--', 'gx-.', 'k_:']): analysis.plot_mds_points(mdsy[6 * i:6 * i + 6], range(6), labels=labels[6 * i:6 * i + 6], style=style)
def make_rdm_and_mds(name, with_goals=False): model = utils.load_object(name, 1) # eg 'noise_test2' if with_goals: hidden = pnashierarchy.accuracy_test_with_goals(model) else: hidden = accuracy_test(model, noise) # Turn into a list of simple vectors for i, tensor in enumerate(hidden): hidden[i] = tensor.numpy().reshape(-1) rdmatrix = analysis.rdm_spearman(hidden) labels = [] for i, sequence in enumerate(pnas2018task.seqs): for action in sequence[1:]: labels.append(str(i) + '_' + action) analysis.plot_rdm(rdmatrix, labels, "Spearman rho matrix") for i in range(4): mdsy = analysis.mds(hidden[6 * i:6 * i + 6]) analysis.plot_mds_points(mdsy, range(len(mdsy)), labels=labels[6 * i:6 * i + 6]) mdsy = analysis.mds(hidden) for i, style in enumerate(['ro-', 'b|--', 'gx-.', 'k_:']): analysis.plot_mds_points(mdsy[6 * i:6 * i + 6], range(6), labels=labels[6 * i:6 * i + 6], style=style, show=(i == 3))
def make_rdm_and_mds(name): model = utils.load_object(name) # eg 'noise_test2' hidden = get_model_hidden_activations(model) rdmatrix = analysis.rdm_spearman(hidden) labels = [] for goal in tce.action_list: for action in tce.action_list[goal]: labels.append(goal + '_' + action) analysis.plot_rdm(rdmatrix, labels, "Spearman rho matrix") mdsy = analysis.mds(hidden) analysis.plot_mds_points(mdsy, range(len(mdsy)), labels=labels)
def make_rdm_noisy(name, num_networks, noise, num_runs_per_network=10, title="-", save_files=True, skips=[], rdm_type=analysis.SPEARMAN): # Make one rdm for each network rdmatrices = [] for i in range(num_networks + len(skips)): if i in skips: continue model = utils.load_object(name, i) hiddens = [] for j in range(num_runs_per_network): hidden, _ = accuracy_test(model, name=str(i), noise=noise) for k, tensor in enumerate(hidden): hidden[k] = tensor.numpy().reshape(-1) hiddens.append(hidden) rdmatrix = analysis.rdm_noisy_mahalanobis(hiddens) rdmatrices.append(rdmatrix) # Now average over all matrices avg_matrix = None for matrix in rdmatrices: if avg_matrix is None: avg_matrix = matrix else: avg_matrix += matrix avg_matrix = avg_matrix / num_networks name = name + '_' + rdm_type np.savetxt(name + "_rdm_mat.txt", avg_matrix, delimiter="\t", fmt='%.2e') labels = [] for i, sequence in enumerate(pnas2018task.seqs): for action in sequence[1:]: labels.append(str(i) + '_' + action) analysis.plot_rdm(avg_matrix, labels, title + " spearman rho matrix") if save_files: plt.savefig(name + '_rdm') plt.clf() mdsy = analysis.mds(avg_matrix) for i, style in enumerate(['ro-', 'b|--', 'gx-.', 'k_:']): analysis.plot_mds_points(mdsy[6 * i:6 * i + 6], range(6), labels=labels[6 * i:6 * i + 6], style=style) plt.title(title) if save_files: plt.savefig(name + '_mds') plt.clf() return avg_matrix
def save_rdm(rdm, name, labels, title, fontsize=0.6, color=analysis.RDM_COLOR_SEQUENTIAL): np.savetxt(name + "_rdm_mat.txt", rdm, delimiter="\t", fmt='%.2e') analysis.plot_rdm(rdm, labels, title + " spearman rho matrix", figsize=30, fontsize=fontsize, color=color) plt.savefig(name + '_rdm.png', dpi=300, bbox_inches='tight') plt.clf()
def make_rdm_multiple_predictive(name, num_networks,title="-", save_files=True): # Make one rdm for each network optimal_list = [] rdmatrices = [] for i in range(num_networks): model = utils.load_object(name, i) hidden, optimal = accuracy_test_predictive(model, i) optimal_list.append(optimal) if optimal: # Turn into a list of simple vectors for i, tensor in enumerate(hidden): hidden[i] = tensor.numpy().reshape(-1) rdmatrix = analysis.rdm_spearman(hidden) rdmatrices.append(rdmatrix) print("{0} networks, of which {1} achieve optimal accuracy".format(num_networks, optimal_list.count(True))) # Now average over all matrices avg_matrix = None for matrix in rdmatrices: if avg_matrix is None: avg_matrix = matrix else: avg_matrix += matrix avg_matrix = avg_matrix / len(rdmatrices) # delete the unwanted rows and columns: #avg_matrix = np.delete(avg_matrix, [0, 6, 12], 0) #avg_matrix = np.delete(avg_matrix, [0, 6, 12], 1) nps = 6 # number of elements per sequence if save_files: np.savetxt(name+".csv", avg_matrix, delimiter=",") labels = [] for i, sequence in enumerate(pnas2018task.seqs): for action in sequence[0:-1]: labels.append(str(i)+'_'+action) analysis.plot_rdm(avg_matrix, labels, title + " spearman rho matrix") if save_files: plt.savefig(name+'_rdm') plt.clf() mdsy = analysis.mds(avg_matrix) for i, style in enumerate(['ro-', 'b|--', 'gx-.']): analysis.plot_mds_points(mdsy[nps * i:nps * i + nps], range(nps), labels=labels[nps * i:nps * i + nps], style=style) plt.title(title) if save_files: plt.savefig(name + '_mds') plt.clf() return avg_matrix
def generate_rdm_bev(nnet, name, rdm_type=analysis.SPEARMAN, save_files=True, title="RDM training beverage only"): if rdm_type != analysis.SPEARMAN: raise Exception("not implemented") hidden, accuracy_totals, accuracy_fullseqs = test_network_bev(nnet) print(accuracy_totals) print(accuracy_fullseqs) hidden = utils.flatten_onelevel(hidden) rdmatrix = analysis.rdm_spearman(hidden) labels = utils.flatten_onelevel(task.label_seqs_bev) name = name.replace('.', '_') + '_' + rdm_type if save_files: np.savetxt(name + "_rdm_mat.txt", rdmatrix, delimiter="\t", fmt='%.2e') analysis.plot_rdm(rdmatrix, labels, title + " spearman rho matrix", figsize=30, fontsize=0.6) if save_files: plt.savefig(name + '_rdm.png', dpi=300, bbox_inches='tight') plt.clf()
def reload(file="hyperparameter_test_rdm.txt"): characteristics = [] for hidden_units in [8, 15, 50]: for loss_type in [pnas2018.CROSS_ENTROPY, pnas2018.MSE]: for l1reg in [0., 0.001]: for l2reg in [0., 0.001]: for algorithm in [ neuralnet.SGD, neuralnet.RMSPROP, neuralnet.ADAM ]: for initialization in [ neuralnet.NORMAL, neuralnet.UNIFORM ]: learning_rate = 0.1 if algorithm == neuralnet.RMSPROP or algorithm == neuralnet.ADAM: learning_rate *= 0.1 if hidden_units == 8: learning_rate *= 2 elif hidden_units == 50: learning_rate *= 0.5 elif loss_type == pnas2018.MSE and ( algorithm != neuralnet.RMSPROP and algorithm != neuralnet.ADAM): learning_rate *= 10 if l1reg == 0.001: L1 = 'l1' else: L1 = '' if l2reg == 0.001: L2 = 'l2' else: L2 = '' if l1reg == l2reg == 0.: L1 = 'no_reg' name = str( hidden_units ) + ' units, ' + loss_type + ', ' + 'LR:{:.2f}'.format( learning_rate ) + ', ' + L1 + L2 + ', ' + algorithm + ', ' + initialization # + "{:.3f}".format(learning_rate) characteristics.append([ name, hidden_units, loss_type, learning_rate, l1reg, l2reg, algorithm, initialization ]) matrix = np.loadtxt(file, delimiter="\t") print(sort_quality(matrix)) rows = matrix.tolist() # Now sort. Ugliest python line ever, what it does is this: # 1. Zip characteristics and rows, so that each row is paired with its characteristics in a tuple # 2. Sort this list of tuple for multiple conditions, using the characteristics in the order given # 3. Retrieve the sorted characteristics and rows separately sorted_stuff = [(sorted_chars, row) for sorted_chars, row in sorted( zip(characteristics, rows), key=lambda x: (x[0][1], x[0][2], x[0][3], x[0][4], x[0][5], x[0][6], x[0][7]))] sorted_rows = [row for (sorted_chars, row) in sorted_stuff] sorted_characteristics = [ sorted_chars for (sorted_chars, row) in sorted_stuff ] # Now transpose and sort again columns = np.asarray(sorted_rows).transpose().tolist() sorted_columns = [ col for _, col in sorted(zip(characteristics, columns), key=lambda x: (x[0][1], x[0][2], x[0][3], x[ 0][4], x[0][5], x[0][6], x[0][7])) ] matrix = np.asarray(sorted_columns) labels = [char[0] for char in sorted_characteristics] # Metric for sort quality: how much difference is there between consecutive values print(sort_quality(matrix)) plt.figure(dpi=200) plt.subplots(figsize=(45, 30)) analysis.plot_rdm(matrix, labels, "Hyperparameter test general spearman matrix", vmin=-0.5, vmax=1.) plt.tight_layout() plt.savefig(file[:-3] + ".png", dpi=300)
def make_rdm_multiple(name, num_networks, with_goals=False, title="-", save_files=True, skips=[], rdm_type=analysis.SPEARMAN, noise=0., save_name=None): # Make one rdm for each network hidden_activations = [] rdmatrices = [] for i in range(num_networks+len(skips)): if i in skips: continue model = utils.load_object(name, i) if with_goals: hidden = pnashierarchy.accuracy_test_with_goals(model) else: hidden, _ = accuracy_test(model, name=str(i), noise=noise) hidden_activations.append(hidden) # Turn into a list of simple vectors for k, tensor in enumerate(hidden): hidden[k] = tensor.numpy().reshape(-1) if rdm_type == analysis.SPEARMAN: rdmatrix = analysis.rdm_spearman(hidden) elif rdm_type == analysis.MAHALANOBIS: rdmatrix = analysis.rdm_mahalanobis(hidden) #rdmatrix = analysis.rdm_noisy2_mahalanobis(hidden) elif rdm_type == analysis.EUCLIDIAN: rdmatrix = analysis.rdm_euclidian(hidden) elif rdm_type ==analysis.CRAPPYNOBIS: rdmatrix = analysis.rdm_crappynobis(hidden) else: raise ValueError("Only implemented rdm types are mahalanobis, spearman, euclidian") rdmatrices.append(rdmatrix) # Now average over all matrices avg_matrix = None for matrix in rdmatrices: if avg_matrix is None: avg_matrix = matrix else: avg_matrix += matrix avg_matrix = avg_matrix / num_networks name=name.replace('.', '_')+'_'+rdm_type if save_files: if save_name is None: save_name = name np.savetxt(save_name+"_rdm.txt", avg_matrix, delimiter="\t", fmt='%.2e') labels = [] for i, sequence in enumerate(rewardtask.seqs): for action in sequence[1:]: labels.append(str(i)+'_'+action) analysis.plot_rdm(avg_matrix, labels, title + " spearman rho matrix") if save_files: plt.savefig(save_name+'_rdm') plt.clf() mdsy = analysis.mds(avg_matrix) for i, style in enumerate(['ro-', 'b|--', 'gx-.', 'k_:']): analysis.plot_mds_points(mdsy[rewardtask.length * i:rewardtask.length * i + rewardtask.length], range(rewardtask.length), labels=labels[rewardtask.length * i:rewardtask.length * i + rewardtask.length], style=style) plt.title(title) if save_files: plt.savefig(save_name + '_mds') plt.clf() return avg_matrix, hidden_activations
def make_rdm_multiple_deepprednet(name, num_networks, with_goals=False, title="-", save_files=True, skips=[], rdm_type=analysis.SPEARMAN): # Make one rdm for each network hidden_activations1 = [] hidden_activations2 = [] rdmatrices1 = [] rdmatrices2 = [] for i in range(num_networks + len(skips)): if i in skips: continue model = utils.load_object(name, i) if with_goals: hidden = pnashierarchy.accuracy_test_with_goals(model) else: hidden1, hidden2, _ = accuracy_test_deepprednet(model, name=str(i)) hidden_activations1.append(hidden1) hidden_activations2.append(hidden2) # Turn into a list of simple vectors for j, tensor in enumerate(hidden1): hidden1[j] = tensor.numpy().reshape(-1) for j, tensor in enumerate(hidden2): hidden2[j] = tensor.numpy().reshape(-1) if rdm_type == analysis.SPEARMAN: rdmatrix1 = analysis.rdm_spearman(hidden1) rdmatrix2 = analysis.rdm_spearman(hidden2) elif rdm_type == analysis.MAHALANOBIS: rdmatrix1 = analysis.rdm_mahalanobis(hidden1) rdmatrix2 = analysis.rdm_mahalanobis(hidden2) elif rdm_type == analysis.EUCLIDIAN: rdmatrix1 = analysis.rdm_euclidian(hidden1) rdmatrix2 = analysis.rdm_euclidian(hidden2) elif rdm_type == analysis.CRAPPYNOBIS: rdmatrix1 = analysis.rdm_crappynobis(hidden1) rdmatrix2 = analysis.rdm_crappynobis(hidden2) else: raise ValueError( "Only implemented rdm types are mahalanobis, spearman, euclidian" ) rdmatrices1.append(rdmatrix1) rdmatrices2.append(rdmatrix2) # Now average over all matrices for level, rdmatrices in enumerate([rdmatrices1, rdmatrices2]): avg_matrix = None for matrix in rdmatrices: if avg_matrix is None: avg_matrix = matrix else: avg_matrix += matrix avg_matrix = avg_matrix / num_networks name_level = name.replace( '.', '_') + '_' + rdm_type + "_level_" + str(level) if save_files: np.savetxt(name_level + "_rdm_mat.txt", avg_matrix, delimiter="\t", fmt='%.2e') labels = [] for i, sequence in enumerate(pnas2018task.seqs): for action in sequence[1:]: labels.append(str(i) + '_' + action) analysis.plot_rdm(avg_matrix, labels, title + " spearman rho matrix") if save_files: plt.savefig(name_level + '_rdm.jpeg') plt.clf() mdsy = analysis.mds(avg_matrix) for i, style in enumerate(['ro-', 'b|--', 'gx-.', 'k_:']): analysis.plot_mds_points(mdsy[6 * i:6 * i + 6], range(6), labels=labels[6 * i:6 * i + 6], style=style) plt.title(title) if save_files: plt.savefig(name_level + '_mds') plt.clf() return
def make_rdm_multiple_ldt(name, num_networks, with_goals=False, title="-", save_files=True, skips=[], rdm_type=analysis.SPEARMAN, noise_during=0., noise_after=0., num_samples=2, initial_context=ZEROS, log_scale=False, save_name=None): # Make one rdm for each network #hidden_activations = [] rdmatrices = [] for i in range(num_networks + len(skips)): if i in skips: continue model = utils.load_object(name, i) hidden = [] for j in range(num_samples): if with_goals: hidden += pnashierarchy.accuracy_test_with_goals(model) else: sample_hidden_activations, _ = accuracy_test( model, name=str(i), noise=noise_during, initial_context=initial_context) hidden += sample_hidden_activations #hidden_activations.append(hidden) # Turn into a list of simple vectors for k, tensor in enumerate(hidden): hidden[k] = tensor.numpy().reshape(-1) # Reshape hidden into a samples x states x activations ndarray. # At this point hidden is as follow: sample1 state1 activation ndarray, sample1 state2 activation nd array, etc. num_states = 24 # = 6 num_activations = model.size_hidden hidden = np.concatenate(hidden, axis=0).reshape( (num_samples, num_states, num_activations)) rdmatrix = analysis.rdm_ldt(hidden, noise=noise_after) rdmatrices.append(rdmatrix) # Now average over all matrices avg_matrix = None for matrix in rdmatrices: if avg_matrix is None: avg_matrix = matrix else: avg_matrix += matrix avg_matrix = avg_matrix / num_networks if log_scale: avg_matrix = np.where(avg_matrix != 0, np.log10(avg_matrix), 0) name = name.replace('.', '_') + '_' + rdm_type if save_files: if save_name is None: save_name = name np.savetxt(save_name + "_rdm_mat.txt", avg_matrix, delimiter="\t", fmt='%.2e') labels = [] for i, sequence in enumerate(pnas2018task.seqs): for action in sequence[1:]: labels.append(str(i) + '_' + action) analysis.plot_rdm( avg_matrix, labels, title + " LD-t matrix" + " (log scale)" if log_scale else "") if save_files: plt.savefig(save_name + '_rdm.jpeg') plt.clf() mdsy = analysis.mds(avg_matrix) for i, style in enumerate(['ro-', 'b|--', 'gx-.', 'k_:']): analysis.plot_mds_points(mdsy[6 * i:6 * i + 6], range(6), labels=labels[6 * i:6 * i + 6], style=style) plt.title(title) if save_files: plt.savefig(name + '_mds') plt.clf() return avg_matrix #, hidden_activations
def make_rdm_multiple_hierarchy(name, num_networks, title="-", save_files=True, file_save_name=None, skips=[]): if file_save_name == None: file_save_name = name # Make one rdm for each network rdmatrices_left = [] rdmatrices_right = [] for i in range(num_networks + len(skips)): # Skip number if skips is not None and i in skips: continue model = utils.load_object(name, i) hidden, _ = accuracy_test_with_goals(model, i) # Turn a list of tensors into a list of np vectors for i, tensor in enumerate(hidden): hidden[i] = tensor.numpy().reshape(-1) # Now cut that in two and make an RDM for each cutoff = int(len(hidden[0]) // 2) left_units = [vector[:cutoff] for vector in hidden] rdm_left = analysis.rdm_spearman(left_units) rdmatrices_left.append(rdm_left) right_units = [vector[cutoff:] for vector in hidden] rdm_right = analysis.rdm_spearman(right_units) rdmatrices_right.append(rdm_right) matrices = [] # Do the same processing for each side (low level/left and high_level/right) for side in [[rdmatrices_left, "_goals"], [rdmatrices_right, "_actions"]]: # Now average over all matrices avg_matrix = None for matrix in side[0]: if avg_matrix is None: avg_matrix = matrix else: avg_matrix += matrix avg_matrix = avg_matrix / num_networks # delete the unwanted rows and columns: avg_matrix = np.delete(avg_matrix, [0, 6, 12], 0) avg_matrix = np.delete(avg_matrix, [0, 6, 12], 1) nps = 5 # number of elements per sequence side_name = file_save_name + side[1] np.savetxt(side_name + "_rdm_mat" + utils.datestr() + ".txt", avg_matrix, delimiter="\t", fmt='%.2e') labels = [] for i, sequence in enumerate(seqs): for action in sequence[1:-1]: labels.append(str(i) + '_' + action) analysis.plot_rdm(avg_matrix, labels, title + side_name + " spearman rho matrix") if save_files: plt.savefig(side_name + '_rdm' + utils.datestr()) plt.clf() # nps = 5 # number of elements per sequence mdsy = analysis.mds(avg_matrix) for i, style in enumerate(['ro-', 'b|--', 'gx-.']): analysis.plot_mds_points(mdsy[nps * i:nps * i + nps], range(nps), labels=labels[nps * i:nps * i + nps], style=style) plt.title(title + side_name) if save_files: plt.savefig(side_name + '_mds' + utils.datestr()) plt.clf() matrices.append(avg_matrix) return matrices
def make_rdm_multiple(name, num_networks, type="spearman", with_goals=False, title="-", save_files=True, skips=[]): # Make one rdm for each network optimal_list = [] rdmatrices = [] error_per_step = np.zeros((3, 6, 11), dtype=np.float32) # number of steps hidden_avg = [] hiddens = np.zeros((3, 6), dtype=np.float32) for i in range(num_networks + len(skips)): if i in skips: continue model = utils.load_object(name, i) if with_goals: hidden, optimal = accuracy_test_with_goals(model, i) else: hidden, optimal, error_per_step_model = accuracy_test(model, i) error_per_step += error_per_step_model optimal_list.append(optimal) # Turn into a list of simple vectors for j, tensor in enumerate(hidden): hidden[j] = tensor.numpy().reshape(-1) hidden_avg.append(np.average( hidden[j])) # Get the average activation for that time-step if type == "spearman": rdmatrix = analysis.rdm_spearman(hidden) elif type == "euclidian": rdmatrix = analysis.rdm_euclidian(hidden) else: raise Exception("RDM type " + type + " not implemented") rdmatrices.append(rdmatrix) # Now i = j = 0 for act_avg in hidden_avg: hiddens[i, j] += act_avg j += 1 if j > 5: j = 0 i += 1 if i > 2: i = 0 j = 0 print(hiddens / num_networks) print("{0} networks, of which {1} achieve optimal accuracy".format( num_networks, optimal_list.count(True))) # Hidden activation per step averages #for i, hidden_act in enumerate(hidden): # hidden[i] = np.average(hidden_act) #hidden_avg = hidden.reshape(18, 11) #print(enumerate(hidden_avg)) # Error per step averages error_avg = error_per_step / 100. error_avg = error_avg.reshape(18, 11) print(error_avg) # Now average over all matrices avg_matrix = None for matrix in rdmatrices: if avg_matrix is None: avg_matrix = matrix else: avg_matrix += matrix avg_matrix = avg_matrix / num_networks # delete the unwanted rows and columns: avg_matrix = np.delete(avg_matrix, [0, 6, 12], 0) avg_matrix = np.delete(avg_matrix, [0, 6, 12], 1) nps = 5 # number of elements per sequence if save_files: np.savetxt(name + "_rdm_mat_" + type + utils.datestr() + ".txt", avg_matrix, delimiter="\t", fmt='%.2e') np.savetxt(name + "_errors" + utils.datestr() + ".txt", error_avg, delimiter="\t", fmt='%.2e') labels = [] for i, sequence in enumerate(seqs): for action in sequence[1:-1]: labels.append(str(i) + '_' + action) analysis.plot_rdm(avg_matrix, labels, title + " " + type + " matrix") if save_files: plt.savefig(name + '_rdm_' + type) plt.clf() mdsy = analysis.mds(avg_matrix) for i, style in enumerate(['ro-', 'b|--', 'gx-.']): analysis.plot_mds_points(mdsy[nps * i:nps * i + nps], range(nps), labels=labels[nps * i:nps * i + nps], style=style) plt.title(title) if save_files: plt.savefig(name + '_mds') plt.clf() return avg_matrix
def make_rdm_multiple_special(name1, name2, num_networks, file_save_name, title, skips1=[], skips2=[]): mats = [] for name, skips in [(name1, skips1), (name2, skips2)]: print(name) # Make one rdm for each network rdmatrices_left = [] rdmatrices_right = [] for i in range(num_networks + len(skips)): # Skip number if skips is not None and i in skips: continue model = utils.load_object(name, i) if name == name1: # Have to do the goal ones first. hidden = accuracy_test_reg_hierarchy(model, i) else: hidden = accuracy_test_reg_hierarchy_nogoals(model, i) # Turn a list of tensors into a list of np vectors for i, tensor in enumerate(hidden): hidden[i] = tensor.numpy().reshape(-1) # Now cut that in two and make an RDM for each cutoff = int(len(hidden[0]) // 2) left_units = [vector[:cutoff] for vector in hidden] rdm_left = analysis.rdm_spearman(left_units) rdmatrices_left.append(rdm_left) right_units = [vector[cutoff:] for vector in hidden] rdm_right = analysis.rdm_spearman(right_units) rdmatrices_right.append(rdm_right) # Do the same processing for each side (low level/left and high_level/right) for side in [rdmatrices_left, rdmatrices_right]: # goals, then actions # Now average over all matrices avg_matrix = None for matrix in side: if avg_matrix is None: avg_matrix = matrix else: avg_matrix += matrix avg_matrix = avg_matrix / num_networks mats.append(avg_matrix) # Now average the average matrices rdmatrices_left = (mats[0] + mats[2]) / 2 rdmatrices_right = (mats[1] + mats[3]) / 2 # Do the same processing for each side (low level/left and high_level/right) for side in [[rdmatrices_left, "_goals"], [rdmatrices_right, "_actions"]]: matrix = side[0] side_name = file_save_name + side[1] np.savetxt(side_name + "_rdm_mat" + utils.datestr() + ".txt", matrix, delimiter="\t", fmt='%.2e') labels = [] for i, sequence in enumerate(pnas2018task.seqs): for action in sequence[1:]: labels.append(str(i) + '_' + action) analysis.plot_rdm(matrix, labels, title + side_name + " spearman rho matrix") plt.savefig(side_name + '_rdm' + utils.datestr()) plt.clf() mdsy = analysis.mds(matrix) for i, style in enumerate(['ro-', 'b|--', 'gx-.', 'k_:']): analysis.plot_mds_points(mdsy[6 * i:6 * i + 6], range(6), labels=labels[6 * i:6 * i + 6], style=style) plt.title(title + side_name) plt.savefig(side_name + '_mds' + utils.datestr()) plt.clf()
def make_rdm_multiple_hierarchy_nogoals(name, num_networks, title="-", save_files=True, file_save_name=None, cutoff=None): if file_save_name == None: file_save_name = name # Make one rdm for each network rdmatrices_left = [] rdmatrices_right = [] for i in range(num_networks): if i == 19: continue model = utils.load_object(name, i) hidden = accuracy_test_reg_hierarchy_nogoals(model, i) # Turn a list of tensors into a list of np vectors for i, tensor in enumerate(hidden): hidden[i] = tensor.numpy().reshape(-1) # Now cut that in two and make an RDM for each if cutoff is None: cutoff = int(len(hidden[0]) // 2) left_units = [vector[:cutoff] for vector in hidden] rdm_left = analysis.rdm_spearman(left_units) rdmatrices_left.append(rdm_left) right_units = [vector[cutoff:] for vector in hidden] rdm_right = analysis.rdm_spearman(right_units) rdmatrices_right.append(rdm_right) # Do the same processing for each side (low level/left and high_level/right) for side in [[rdmatrices_left, "_goals"], [rdmatrices_right, "_actions"]]: # Now average over all matrices avg_matrix = None for matrix in side[0]: if avg_matrix is None: avg_matrix = matrix else: avg_matrix += matrix avg_matrix = avg_matrix / num_networks side_name = file_save_name + side[1] np.savetxt(side_name + "_rdm_mat" + utils.datestr() + ".csv", avg_matrix, delimiter=",") labels = [] for i, sequence in enumerate(pnas2018task.seqs): for action in sequence[1:]: labels.append(str(i) + '_' + action) analysis.plot_rdm(avg_matrix, labels, title + side_name + " spearman rho matrix") if save_files: plt.savefig(side_name + '_rdm' + utils.datestr()) plt.clf() mdsy = analysis.mds(avg_matrix) for i, style in enumerate(['ro-', 'b|--', 'gx-.', 'k_:']): analysis.plot_mds_points(mdsy[6 * i:6 * i + 6], range(6), labels=labels[6 * i:6 * i + 6], style=style) plt.title(title + side_name) if save_files: plt.savefig(side_name + '_mds' + utils.datestr()) plt.clf()