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()
