def ws_figure():
ws_results = utilities.load_object("MC_N500_c1_e10_train1k_gain1_mu-ws_final_results.pyobj")
# Contour plot
print(ws_results['parameters'])
listQ1_listQ2_listTrials_mc = np.array([[[k[2][0] for k in j] for j in i] for i in ws_results['results']])
q1 = ws_results['parameters']['q1_list']
q2 = ws_results['parameters']['q2_list']
levels = [1,2,3,4,5,6,7,8,9,10,11]
X, Y = np.meshgrid(q1, q2)
Z = np.zeros((len(q2),len(q1)))
for i, listQ2_listTrials_mc in enumerate(listQ1_listQ2_listTrials_mc):
for j, listTrials_mc in enumerate(listQ2_listTrials_mc):
# print listTrials_nrmse, X[j,i], Y[j,i])
Z[j,i] = np.mean(listTrials_mc)
if levels==None:
cont = plt.contourf(X, Y, Z, cmap=cm.magma)
else:
cont = plt.contourf(X, Y, Z, cmap=cm.magma, levels=levels)
cbar = plt.colorbar(cont)
cbar.set_label("${MC}$")
plt.xlabel("$\mu$", fontsize=30)
plt.ylabel("$W_s$", fontsize=30)
plt.tight_layout()
plt.savefig("supp_ws_figure.pdf")
plt.close()
plt.clf()
def main(argv):
experiment_parameter_file = str(argv[0])
chunkID = str(argv[1])
experimental_parameters = utilities.load_object(experiment_parameter_file)
results = worker(experimental_parameters)
utilities.save_object(results, experimental_parameters[0]['full_path'] +\
experimental_parameters[0]['command_prefix'] + "_output" + chunkID + ".pyobj")
def main(argv):
if len(argv) == 0:
print """
Call as: bigred2_result_consolidation command_prefix path
Where path is the full working directory where the files are locations
"""
command_prefix = str(argv[0])
full_path = str(argv[1])
parameters = utilities.load_object(full_path + command_prefix + "_paramfile.pyobj")
output_file_list = utilities.load_object(full_path + command_prefix + "_outputfilelist.pyobj")
results = consolidate_data(parameters, output_file_list)
utilities.save_object({'parameters': parameters, 'results': results}, full_path + command_prefix + "_final_results.pyobj")
cleanup(command_prefix, full_path, output_file_list)
def spectral_rsig_figure():
spectral_ws_results = utilities.load_object("const_spectral_MC_N500_c1_e10_train1k_ws1.132_gain1.0_com10_mu_v_rsig_final_results.pyobj")
# f, ax = plt.subplots(1, 2, figsize=(12,5))
# # Slice through contour
# index1 = 7
# listQ1_listQ2_listTrials_mc = np.array([[[k[2][0] for k in j] for j in i] for i in spectral_ws_results['results']])
# listQ_listTrials_mc = listQ1_listQ2_listTrials_mc[:,index1,:]
# q = spectral_ws_results['parameters']['q1_list']
# list_means = []
# list_CIhigh = []
# list_CIlow = []
# for trials in listQ_listTrials_mc:
# print(len(trials))
# list_means.append(np.mean(trials))
# list_CIhigh.append(stats.sem(trials))
# list_CIlow.append(stats.sem(trials))
# ax[0].errorbar(q, list_means, yerr=[list_CIlow, list_CIhigh],
# marker='o', ls='-', color='blue')
# ax[0].set_ylabel("${MC}$", fontsize=20)
# ax[0].set_xlabel("$\mu$", fontsize=30)
# ax[0].set_ylim(ymin=0.0)
# Contour plot
print(spectral_ws_results['parameters'])
listQ1_listQ2_listTrials_mc = np.array([[[k[2][0] for k in j] for j in i] for i in spectral_ws_results['results']])
q1 = spectral_ws_results['parameters']['q1_list']
q2 = spectral_ws_results['parameters']['q2_list']
levels = np.linspace(4.0,11.0,8)
X, Y = np.meshgrid(q1, q2)
Z = np.zeros((len(q2),len(q1)))
for i, listQ2_listTrials_mc in enumerate(listQ1_listQ2_listTrials_mc):
for j, listTrials_mc in enumerate(listQ2_listTrials_mc):
# print listTrials_nrmse, X[j,i], Y[j,i])
Z[j,i] = np.mean(listTrials_mc)
if levels==None:
cont = plt.contourf(X, Y, Z, cmap=cm.magma)
else:
cont = plt.contourf(X, Y, Z, cmap=cm.magma, levels=levels)
cbar = plt.colorbar(cont)
cbar.set_label("${MC}$")
plt.xlabel("$\mu$", fontsize=30)
plt.ylabel("$r_{\mathrm{sig}}$", fontsize=30)
plt.tight_layout()
plt.savefig("supp_spectral_rsig_figure.pdf")
plt.close()
plt.clf()
def consolidate_data(parameters, output_file_list):
model_results = []
for file in output_file_list:
model_results += utilities.load_object(file)
num_q1 = len(parameters['q1_list'])
num_q2 = len(parameters['q2_list'])
num_trial = parameters['parameters']['num_reservoir_samplings']
listQ1_listQ2_listTrial_listResults = [ [ [ model_results[i*num_q2*num_trial + j*num_trial + k]
for k in xrange(num_trial) ]
for j in xrange(num_q2) ]
for i in xrange(num_q1) ]
return listQ1_listQ2_listTrial_listResults
def spectral_figure():
spectral_results = utilities.load_object("/home/nathaniel/workspace/function_of_modularity/MC_N500_ws1.132_com10_spectrum.pyobj")
mu_array = np.linspace(0.0, 0.5, 20)
first_mean = []
first_sem = []
for bytrial_byspectrum in spectral_results['adj_eigvals']:
largest_by_trial = [ spectrum[-1] for spectrum in bytrial_byspectrum ]
first_mean.append(np.mean(largest_by_trial))
first_sem.append(stats.sem(largest_by_trial) * 1.97) # Turn SEM to ~95% interval
second_mean = []
second_sem = []
for bytrial_byspectrum in spectral_results['adj_eigvals']:
second_by_trial = [ spectrum[-2] for spectrum in bytrial_byspectrum ]
second_mean.append(np.mean(second_by_trial))
second_sem.append(stats.sem(second_by_trial) * 1.97) # Turn SEM to ~95% interval
gap_mean = []
gap_sem = []
for bytrial_byspectrum in spectral_results['adj_eigvals']:
gap_by_trial = [ spectrum[-1] - spectrum[-2] for spectrum in bytrial_byspectrum ]
gap_mean.append(np.mean(gap_by_trial))
gap_sem.append(stats.sem(gap_by_trial) * 1.97) # Turn SEM to ~95% interval
fig, ax1 = plt.subplots()
l1 = ax1.errorbar(mu_array, first_mean, yerr=[second_sem, second_sem],
marker='o', ls='-', color='black')
l2 = ax1.errorbar(mu_array, second_mean, yerr=[second_sem, second_sem],
marker='o', ls='-', color='blue')
ax2 = ax1.twinx()
l3 = ax2.errorbar(mu_array, gap_mean, yerr=[gap_sem, gap_sem],
marker='o', ls='--', color='red')
ax1.set_xlabel(r"$\mu$")
ax1.set_ylabel("eigenvalue")
ax2.set_ylabel("gap", color='r')
ax2.tick_params('y', colors='r')
fig.legend((l1, l2, l3), ('largest eigenvalue', 'second largest eigenvalue',
'spectral gap'), loc="upper center", frameon=False, bbox_to_anchor=(0., 0.94, 1., 0))
fig.tight_layout()
plt.savefig("supp_spectrum.pdf")
plt.close()
plt.clf()
'legend.fontsize': 16, \
'xtick.labelsize': 20, \
'ytick.labelsize': 20, \
'text.usetex': True, \
'xtick.major.size': 10, \
'ytick.major.size': 10, \
'xtick.minor.size': 8, \
'ytick.minor.size': 8, \
'xtick.major.width': 1.0, \
'ytick.major.width': 1.0, \
'xtick.minor.width': 1.0, \
'ytick.minor.width': 1.0}
plt.rcParams.update(params)
# Load results
results = utilities.load_object('/home/nathaniel/workspace/DiscreteESN/nbit_N1k_dl4-5_recall_task/c1_e10_N1k_rsig0.3_gain2.0_ws1.0_lrb-0.1_urb1.0_dl4-5_mu-seq_final_results.pyobj')
prefix = 'test'
# Print results
print(results['parameters'])
# sys.exit()
# Pick q1 and q1
q1_index = 0
q2_index = 7
full_path = "/home/nathaniel/workspace/DiscreteESN/"
# Train network in task
nbit_task_master = get_validated_taskmaster(results, q1_index, q2_index, full_path)
# Untrained random input response
'xtick.major.size': 10,
'ytick.major.size': 10,
'xtick.minor.size': 8,
'ytick.minor.size': 8,
'xtick.major.width': 1.0,
'ytick.major.width': 1.0,
'xtick.minor.width': 1.0,
'ytick.minor.width': 1.0,
'pdf.fonttype': 42,
'ps.fonttype': 42
}
plt.rcParams.update(params)
prefix = 'MC_N500_c1_e10_train1k_ws1.132_gain1.0_com10_mu_v_rsig_select'
final_results = utilities.load_object(
'/home/nathaniel/workspace/function_of_modularity/' + prefix +
'_final_results.pyobj')
print(final_results['parameters'])
# # Contour plot
# # final_results = utilities.load_object('/home/nathaniel/workspace/function_of_modularity/' + prefix + '_final_results.pyobj')
# listQ1_listQ2_listTrials_nrmse = np.array([[[k[2][0] for k in j] for j in i] for i in final_results['results']])
# # listQ1_listQ2_listTrials_nrmse = np.array(final_results['results'])[:,:,:,2]
# performance_contour_plot(prefix, final_results['parameters']['q1_list'],
# final_results['parameters']['q2_list'], listQ1_listQ2_listTrials_nrmse,
# r'$\mu$',r'$r_{\textup{sig}}$', 'Score', logx=False, logy=False, logz=False)#,, levels=np.linspace(0.0,20.0,21) )#r'${urb}$', r'${lrb}$'
# MC curve
# final_results = utilities.load_object('/home/nathaniel/workspace/function_of_modularity/' + prefix + '_final_results.pyobj')
# print(final_results['parameters'])
# i1, i2 = 13, 2
# # Parallelize function
# SimulateCurcuit.parallel = parallel_function(SimulateCurcuit)
# model_results = SimulateCurcuit.parallel(parallel_input_sequence)
# # Re-order output
# listRatios_listMus_listTrials_listResults = [ [ [ model_results[(num_trials*num_ratios*i + num_trials*j + k)] \
# for k in xrange(num_trials)] \
# for i in xrange(num_mus)] \
# for j in xrange(num_ratios) ]
# listRatios_listMus_listMeanResults = [ [ np.mean([ model_results[(num_trials*num_ratios*i + num_trials*j + k)] \
# for k in xrange(num_trials)], axis=0) \
# for i in xrange(num_mus)] \
# for j in xrange(num_ratios) ]
# # Sort
# sorted_listRatios_listMus_listMeanResults = sorted([ sorted(inner_list, key=lambda x: x[0]) for inner_list in listRatios_listMus_listMeanResults ], key=lambda x: x[0][1])
# utilities.save_object((sorted(list_mus), sorted(list_signal_ratio), sorted_listRatios_listMus_listMeanResults, listRatios_listMus_listTrials_listResults), prefix + "_simresults_vs_mu_vs_signal.pyobj")
# Plot results
list_mus, list_signal_ratio, sorted_listRatios_listMus_listMeanResults, \
listRatios_listMus_listTrials_listResults = utilities.load_object(prefix + "_simresults_vs_mu_vs_signal.pyobj")
activity_contour_plot(prefix, list_mus, list_signal_ratio, sorted_listRatios_listMus_listMeanResults)
activity_vs_mu_plot(prefix, 6, list_mus, list_signal_ratio, listRatios_listMus_listTrials_listResults)
# fixed_point_contour_plot(prefix, list_mus, list_signal_ratio, sorted_listRatios_listMus_listMeanResults, levels=np.linspace(0,1,11))
# fixed_point_vs_mu_plot(prefix, 3, list_mus, list_signal_ratio, listRatios_listMus_listTrials_listResults)
# halting_time_contour_plot(prefix, list_mus, list_signal_ratio, sorted_listRatios_listMus_listMeanResults)
# halting_time_vs_mu_plot(prefix, 3, list_mus, list_signal_ratio, listRatios_listMus_listTrials_listResults)
# time_to_activation_contour_plot(prefix, list_mus, list_signal_ratio, sorted_listRatios_listMus_listMeanResults)
# time_to_activation_vs_mu_plot(prefix, 0, list_mus, list_signal_ratio, listRatios_listMus_listTrials_listResults)
def overlap_figure():
f, ax = plt.subplots(1, 2, figsize=(12,5))
ax2 = ax[0].twinx()
perf_results = utilities.load_object("/home/nathaniel/workspace/function_of_modularity/MC_N500_c1_e10_train1k_ws1.132_gain1.0_com10_mu_v_rsig_version2_final_results.pyobj")
list_mus, list_signal_ratio, listRatios_listMus_listMeanResults, \
listRatios_listMus_listTrials_listResults = utilities.load_object("/home/nathaniel/workspace/function_of_modularity/N500_randinput_trials100_same_as_MC_task_simresults_vs_mu_vs_signal.pyobj")
# Divide by duration and size of network to normalize
oX, oY = np.meshgrid(list_mus, list_signal_ratio)
oZ = np.zeros(shape=(len(list_signal_ratio), len(list_mus)))
for i, listMus_listMeanResults in enumerate(listRatios_listMus_listMeanResults):
for j, listMeanResults in enumerate(listMus_listMeanResults):
oZ[i,j] = listMeanResults[3] /500./1000.# divide by cirtuit size and duration
listQ1_listQ2_listTrials_mc = np.array([[[k[2][0] for k in j] for j in i] for i in perf_results['results']])
q1 = perf_results['parameters']['q1_list']
q2 = perf_results['parameters']['q2_list']
levels = np.linspace(4.0,11.0,8)
X, Y = np.meshgrid(q1, q2)
Z = np.zeros((len(q2),len(q1)))
for i, listQ2_listTrials_mc in enumerate(listQ1_listQ2_listTrials_mc):
for j, listTrials_mc in enumerate(listQ2_listTrials_mc):
Z[j,i] = np.mean(listTrials_mc)
# Slice through contour
index1 = 9
listQ1_listQ2_listTrials_mc = np.array([[[k[2][0] for k in j] for j in i] for i in perf_results['results']])
listQ_listTrials_mc = listQ1_listQ2_listTrials_mc[:,index1,:]
q = perf_results['parameters']['q1_list']
means = []
sems = []
for trials in listQ_listTrials_mc:
means.append(np.mean(trials))
sems.append(stats.sem(trials))
l1 = ax[0].errorbar(q, means, yerr=[sems, sems],
marker='o', ls='-', color='blue')
ax[0].set_ylabel("${MC}$", fontsize=20)
ax[0].set_xlabel("$\mu$", fontsize=30)
ax[0].set_ylim(ymin=0.0)
means = []
sems = []
for trials in np.array(listRatios_listMus_listTrials_listResults)[index1,:,:,3]/500./1000.:# divide by cirtuit size and duration
means.append(np.mean(trials))
sems.append(stats.sem(trials))
l2 = ax2.errorbar(q, means, yerr=[sems, sems],
marker='^', ls='--', color='red')
ax2.set_ylabel("\\text{Activity}", fontsize=20, color='r')
ax2.tick_params('y', colors='r')
ax2.set_xlabel("$\mu$", fontsize=30)
ax2.set_ylim(ymin=0.0)
# f.legend((l1, l2), ("${MC}$", 'Normalized activity'),
# loc="lower center", frameon=False, bbox_to_anchor=(0., 0.5, 1., 0))
if levels==None:
cont = ax[1].contourf(X, Y, Z, cmap=cm.magma)
else:
cont = ax[1].contourf(X, Y, Z, cmap=cm.magma, levels=levels)
cbar = plt.colorbar(cont, ax=ax[1])
cbar.set_label("${MC}$")
cont2 = ax[1].contour(oX, oY, oZ, colors='k', linewidths=1.5)
ax[1].clabel(cont2, fontsize=10, inline=1)
ax[1].axhline(q2[index1], ls='--', lw=1., color='w')
ax[1].set_xlabel("$\mu$", fontsize=30)
ax[1].set_ylabel("$r_{\mathrm{sig}}$", fontsize=30)
ax[0].text(-0.15, 1.0, '(a)', fontsize=25, fontname='Myriad Pro', transform = ax[0].transAxes)
ax[1].text(-0.25, 1.0, '(b)', fontsize=25, fontname='Myriad Pro', transform = ax[1].transAxes)
plt.tight_layout()
plt.savefig("supp_mc_optmod_contour.pdf")
plt.close()
plt.clf()
from UI import *
from smoothing import Smoothing
import pygame
from pygame.locals import *
#############################################################
camera = CAMERAS[which_camera]
decimation = decimations[which_camera] #decimation factor for showing image
camera_object = Camera(camera)
marker_object = Markers()
stylus_object = Stylus(which_stylus, stylus_length, camera_object.mtx, camera_object.dist)
print('Stylus:', which_stylus)
smoothing_object = Smoothing()
wb, sheet, board_parameters, hotspots, labels, labels_secondary = load_object(object_path+object_fname)
sound_object = Sounds(object_path, labels, labels_secondary)
cap = cv2.VideoCapture(int_or_ext)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT,camera_object.h) #set camera image height
cap.set(cv2.CAP_PROP_FRAME_WIDTH,camera_object.w) #set camera image width
cap.set(cv2.CAP_PROP_FOCUS,0) #set focus #5 often good for smaller objects and nearer camera
print('Image height, width:', camera_object.h, camera_object.w)
cnt = 0
timestamp0, next_scheduled_ambient_sound = time.time(), 0.
pose_known = False
stylus_info_at_location_1, stylus_info_at_location_2, stylus_info_at_location_a, stylus_info_at_location_b = None, None, None, None
pose, plane_pose, Tca, stylus_location_XYZ_anno = None, None, None, None
current_hotspot = 0
obs_smoothed_old = 0
plt.tight_layout()
plt.savefig(prefix + '_q1_q2_mc_contour.png')
plt.clf()
plt.close()
if __name__ == '__main__':
"""
"""
prefix = 'MC_bin_N500_c1_e10_ws1.132_gain1_p-lin_mu_vs_rsig2'
# 1D Plot - dynamic range
final_results = utilities.load_object(
'/home/nathaniel/workspace/DiscreteESN/dynamic_range_code/' + prefix +
'_final_results.pyobj')
print(final_results['parameters'])
# structure: Q1 -> Q2 -> samplings -> success_rates -> (q1, q2, p, (MC, delay, coeff), F)
Aq1_Aq2_Asample_Arates_F = np.array([[[[result[4] for result in k]
for k in j] for j in i]
for i in final_results['results']])
Aq1_Aq2_Asample_Arates_p = np.array([[[[result[2] for result in k]
for k in j] for j in i]
for i in final_results['results']])
Aq1_Aq2_Asample_Arates_MC = np.array([[[[result[3][0] for result in k]
for k in j] for j in i]
for i in final_results['results']])
plot_mc_vs_p(prefix, Aq1_Aq2_Asample_Arates_p[0, 0, 0, :],
Aq1_Aq2_Asample_Arates_MC[0, 0, 0, :])
'ytick.major.size': 10,
'xtick.minor.size': 8,
'ytick.minor.size': 8,
'xtick.major.width': 1.0,
'ytick.major.width': 1.0,
'xtick.minor.width': 1.0,
'ytick.minor.width': 1.0,
'pdf.fonttype': 42,
'ps.fonttype': 42
}
plt.rcParams.update(params)
f, ax = plt.subplots(2, 2, figsize=(12, 10))
ratio_index = 7
list_mus, list_signal_ratio, listRatios_listMus_listMeanResults, \
listRatios_listMus_listTrials_listResults = utilities.load_object("paper_version_rw0.4_iw3_is0.5_k6_simresults_vs_mu_vs_signal.pyobj")
# Uses net FP index=12
X, Y = np.meshgrid(list_mus, list_signal_ratio)
Z = np.zeros(shape=(len(list_signal_ratio), len(list_mus)))
for i, listMus_listMeanResults in enumerate(
listRatios_listMus_listMeanResults):
for j, listMeanResults in enumerate(listMus_listMeanResults):
Z[i, j] = listMeanResults[12] / 500. # divide by cirtuit size
# [0,1]
levels = np.linspace(0, 1, 11)
if levels == None:
cont = ax[0, 1].contourf(X, Y, Z, cmap=cm.magma)
else:
cont = ax[0, 1].contourf(X, Y, Z, cmap=cm.magma, levels=levels)
