def build_trans_tables(retrieved, key, L):
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo,
cm, a, U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0,
g, random_seed, p_0, n_p, nSnap, russo2008_mode, muted_prop) = \
file_handling.load_parameters(key)
n_seeds = len(retrieved)
num_tables = [[] for order in range(L + 1)]
proba_tables = [[] for order in range(L + 1)]
print('Table creation')
for order in tqdm(range(L)):
chain_length = order + 1
num_tables[order] = sparse.DOK(
shape=tuple([p for ii in range(chain_length)]))
print('Fill num_tables')
for kick_seed in tqdm(range(n_seeds)):
for cue_ind in range(p):
if isinstance(retrieved[kick_seed][cue_ind], list) \
and len(retrieved[kick_seed][cue_ind]) >= 3:
# print(len(retrieved[kick_seed][cue_ind]))
sequence = []
sequence = retrieved[kick_seed][cue_ind][3:]
for ind_trans in range(len(sequence) - L - 1):
trans_string = sequence[ind_trans:ind_trans + L + 1]
for order in range(L):
string = trans_string[:order + 1]
num_tables[order][tuple(string)] += 1
print('Table conversion')
for order in tqdm(range(L)):
num_tables[order] = sparse.COO(num_tables[order])
proba_tables[order] = num_tables[order] / num_tables[order].sum()
return num_tables, proba_tables
def plot_information_flow(simulation_list):
for ind_key in range(len(simulation_list)):
print('ind_key = %d' % ind_key)
simulation_key = simulation_list[ind_key]
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo, cm, a,
U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0, g,
random_seed, p_0, n_p, nSnap,
russo2008_mode) = file_handling.load_parameters(simulation_key)
retrieved_saved = \
file_handling.load_retrieved_several(n_seeds[ind_key], simulation_key)
m_saved, mi_saved, control, shuffled = get_mi(retrieved_saved,
retrieved_saved)
corrected = np.array(mi_saved)[:, None] - np.array(shuffled)
# print((np.array(mi_saved)).shape)
# print((np.array(shuffled)).shape)
# print(corrected.shape)
plt.title('Information flow, shuffled bias estimate')
plt.plot(m_saved,
corrected,
'-o',
color=color_s[ind_key],
label=r'$g_A$=%.1f, $w$=%.1f' % (g_A, w))
plt.plot(m_saved, shuffled, ':', color=color_s[ind_key], label='bias')
# plt.yscale('log', basey=10)
plt.ylim([ymin, ymax])
plt.xlabel(r'Shift $\Delta n$')
plt.legend(loc='upper right')
def plot_lamb_hist_kwang_il(simulation_list):
labels = []
# def plot_lamb_hist(simulation_list):
for ind_key in range(len(simulations)):
print('ind_key = %d' % ind_key)
simulation_key = simulations[ind_key]
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo,
cm, a, U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0,
g, random_seed, p_0, n_p, nSnap, russo2008_mode) = \
file_handling.load_parameters(simulation_key+'.pkl')
labels.append(r"$g_A$=%.2f" % g_A)
lamb = file_handling.load_overlap(simulation_key + '.txt')
lamb_1D = np.zeros(file_handling.event_counter(lamb, p))
cpt = 0
for ind_cue in range(len(lamb)):
for ind_trans in range(len(lamb[ind_cue])):
lamb_1D[cpt] = lamb[ind_cue][ind_trans]
cpt += 1
sns.distplot(lamb_1D)
plt.xlabel(r'$\lambda$')
plt.ylabel('Density')
plt.title(r'w=' + str(w) + ', Gsln')
plt.legend(labels)
def plot_information_flow_apf(simulation_list):
g_A_s = np.array([0., 0.5, 1.])
apf_s = np.array([0., 0.05, 0.1, 0.2, 0.4])
n_gA = len(g_A_s)
n_apf = len(apf_s)
for ind_key in range(len(simulation_list)):
print('ind_key = %d' % ind_key)
simulation_key = simulation_list[ind_key]
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo, cm, a,
U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0, g,
random_seed, p_0, n_p, nSnap, russo2008_mode,
muted_prop) = file_handling.load_parameters(simulation_key)
retrieved_saved = file_handling.load_retrieved_several(
n_seeds[ind_key], simulation_key)
m_saved, mi_saved, control, shuffled, auto_corr, auto_corr_shuff = \
get_mi(retrieved_saved, retrieved_saved)
auto_corr[1] = 0
corrected = np.array(mi_saved)[:, None] - np.array(shuffled)
ind_gA = [i for i in range(len(g_A_s)) if g_A_s[i] == g_A][0]
ind_apf = [i for i in range(len(apf_s)) if apf_s[i] == a_pf][0]
print((np.array(mi_saved)).shape)
print((np.array(shuffled)).shape)
print(corrected.shape)
plt.figure('Mi')
plt.subplot(n_gA // 2 + n_gA % 2, 2, ind_gA + 1)
plt.title('g_A=%.1f, w=%.1f' % (g_A, w))
plt.plot(m_saved,
corrected,
'-o',
color=color_s[ind_apf],
label=r'$a_{pf}$=%.2f' % a_pf)
plt.plot(m_saved, shuffled, ':', color=color_s[ind_apf], label='bias')
plt.yscale('log', basey=10)
plt.ylim([ymin, ymax])
plt.xlabel(r'Shift $\Delta n$')
plt.legend(loc='upper right')
plt.figure('Autocor')
plt.subplot(n_apf // 2 + n_apf % 2, 2, ind_apf + 1)
plt.plot(m_saved,
auto_corr,
'-o',
color=color_s[ind_gA],
label=r'$g_A$=%.1f' % g_A)
plt.plot(m_saved, auto_corr_shuff, ':', color=color_s[ind_gA])
plt.yscale('log')
plt.title(r'$a_{pf}$=%.2f' % a_pf)
plt.ylabel('Correlation')
plt.xlabel(r'$\Delta n$')
plt.figure('Mi')
plt.tight_layout()
plt.figure('Autocor')
plt.legend()
plt.tight_layout()
def trio_prob_table(retrieved, key):
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo,
cm, a, U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0,
g, random_seed, p_0, n_p, nSnap, russo2008_mode, muted_prop) = \
file_handling.load_parameters(key)
n_seeds = len(retrieved)
num_ABC = np.zeros((p, p, p), dtype=int)
num_AB = np.zeros((p, p), dtype=int)
num_A = np.zeros(p, dtype=int)
num_B = num_A.copy()
p_B_ABC = np.nan * np.ones((p, p, p), dtype=float)
p_AB_ABC = np.nan * np.ones((p, p, p), dtype=float)
p_A = np.nan * np.ones(p, dtype=float)
p_B = np.nan * np.ones(p, dtype=float)
for kick_seed in range(n_seeds):
for cue_ind in range(p):
if isinstance(retrieved[kick_seed][cue_ind], list) \
and len(retrieved[kick_seed][cue_ind]) >= 3:
# print(len(retrieved[kick_seed][cue_ind]))
duration = len(retrieved[kick_seed][cue_ind])
if cue_ind != retrieved[kick_seed][cue_ind][0]:
duration += 1
# ind_max[cue_ind] = duration
sequence = []
if cue_ind != retrieved[kick_seed][cue_ind][0]:
sequence.append(cue_ind)
sequence += retrieved[kick_seed][cue_ind]
sequence = sequence[3:]
for ind_trans in range(len(sequence) - 2):
pattA = sequence[ind_trans]
pattB = sequence[ind_trans + 1]
pattC = sequence[ind_trans + 2]
num_AB[pattA, pattB] += 1
num_A[pattA] += 1
num_B[pattB] += 1
num_ABC[pattA, pattB, pattC] += 1
p_A = num_A / np.sum(num_A)
p_B = num_B / np.sum(num_B)
p_AB = num_AB / np.sum(num_B)
occuring_B = num_B != 0
# print(num_B)
# print(num_B.shape)
p_B_ABC[:, occuring_B, :] = num_ABC[:, occuring_B, :] \
/ num_B[None, occuring_B, None]
occuring_AB = num_AB != 0
p_AB_ABC[occuring_AB, :] = num_ABC[occuring_AB, :] \
/ num_AB[occuring_AB, None]
p_ABC = num_ABC / np.sum(num_B)
return num_A, p_A, num_B, p_B, num_AB, p_AB, num_ABC, p_ABC, p_B_ABC, \
p_AB_ABC
def compare_mi_crossovere(simulation_list):
for ind_sim in range(len(simulation_list)):
simulation = simulation_list[ind_sim]
retrieved_saved = file_handling.load_retrieved(simulation)
lamb = file_handling.load_overlap(simulation)
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo, cm, a,
U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0, g,
random_seed, p_0, n_p, nSnap,
russo2008_mode) = file_handling.load_parameters(simulation)
thresholds = np.linspace(0.1, 0.9, 10)
mi_high_s = thresholds.copy()
mi_low_s = thresholds.copy()
shuffled_high_s = thresholds.copy()
shuffled_low_s = thresholds.copy()
random_high_s = thresholds.copy()
random_low_s = thresholds.copy()
for ii in range(len(thresholds)):
threshold = thresholds[ii]
mi_high, mi_low, shuffled_high, shuffled_low, random_high, random_low = \
get_mi_crossovers(retrieved_saved, lamb, threshold)
mi_high_s[ii] = mi_high
mi_low_s[ii] = mi_low
shuffled_high_s[ii] = shuffled_high
shuffled_low_s[ii] = shuffled_low
random_low_s[ii] = random_high
random_high_s[ii] = random_low
plt.subplot(3, 2, ind_sim + 1)
plt.plot(thresholds,
mi_high_s - shuffled_high_s,
'b',
label='Corrected high')
plt.plot(thresholds,
mi_low_s - shuffled_low_s,
'g',
label='Corrected low')
plt.plot(thresholds, mi_high_s, ':b', label='Original high')
plt.plot(thresholds, mi_low_s, ':g', label='Original how')
plt.plot(thresholds, shuffled_high_s, '--b', label='Bias high')
plt.plot(thresholds, shuffled_low_s, '--g', label='Bias low')
plt.ylabel('Mutual information in pairs (m=2)')
plt.xlim(0, 1)
plt.title('w=%.2f, g_A=%.2f' % (w, g_A))
if ind_sim == 0:
plt.legend()
if ind_sim in [4, 5]:
plt.xlabel('Overlap threshold')
def plot_cycles(retrieved, simulation_key):
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo, cm, a, U,
w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0, g, random_seed,
p_0, n_p, nSnap, russo2008_mode,
_) = file_handling.load_parameters(simulation_key)
# retrieved_saved = file_handling.load_ryom_retrieved(ryom_name)
kick_seed = 0
retrieved_saved = retrieved[kick_seed]
cue_number = len(retrieved_saved)
max_cycle = 11
cycle_count = {}
random_cycle_count = {}
max_count = 0
for size_cycle in range(1, max_cycle + 1):
for cue_ind in range(cue_number):
sequence = []
if cue_ind != retrieved_saved[cue_ind][0]:
sequence.append(cue_ind)
sequence += retrieved_saved[cue_ind]
for ind_trans in range(len(sequence) - size_cycle):
cycle = sequence[ind_trans:ind_trans + size_cycle]
cycle = tuple(cycle)
# print(cycle)
if cycle in cycle_count:
cycle_count[cycle] += 1
else:
cycle_count[cycle] = 1
for cycle in list(cycle_count):
if cycle_count[cycle] <= 1:
cycle_count.pop(cycle)
for cycle in cycle_count:
max_count = max(cycle_count[cycle], max_count)
bins = np.arange(1, max_count, 1, dtype=int)
data = np.zeros((max_count + 1, max_cycle + 1))
xx = np.arange(0, max_cycle + 1, 1)
yy = np.arange(0, max_count + 1, 1)
XX, YY = np.meshgrid(xx, yy)
for cycle in cycle_count:
data[cycle_count[cycle], len(cycle)] += 1
plt.pcolor(XX, YY, data, norm=colors.LogNorm(vmin=1, vmax=5e3))
plt.xlim(1, max_cycle)
plt.ylim(1, 1000)
cbar = plt.colorbar()
plt.yscale('log')
def test_shuffle_error(N, p):
mi = []
xx = np.logspace(2, np.log10(N), 100, dtype=int)
for n in xx:
print(np.log(n) / np.log(2))
deck = np.arange(0, n, 1, dtype=int)
rd.shuffle(deck)
test_list = rd.randint(0, p, n)
shuffled = test_list[deck]
mi.append(mutual_information(test_list, shuffled, p)[2])
G = 1 / 2 / np.log(2) * (p - 1)**2
A = G / 6.5
plt.plot(xx, mi, '--', label='Shuffled')
plt.plot(xx, G / (A + xx), '--', label='First order Pan+96a')
plt.yscale('log', basey=2)
plt.xscale('log', basex=2)
plt.xlabel('Number of samples')
plt.ylabel('Sampling error')
for ind_key in range(len(simulations)):
print('ind_key = %d' % ind_key)
simulation_key = simulations[ind_key]
ryom_name = ryom_data[ind_key]
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo, cm, a,
U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0, g,
random_seed, p_0, n_p, nSnap,
russo2008_mode) = file_handling.load_parameters(simulation_key)
retrieved_saved = file_handling.load_retrieved(simulation_key)
ryom_retrieved = file_handling.load_ryom_retrieved(ryom_name)
plt.vlines(event_counter(retrieved_saved),
0,
2**3,
colors=color_s[ind_key])
plt.vlines(event_counter(ryom_retrieved),
0,
2**3,
colors=color_s_ryom[ind_key])
plt.ylim([ymin, ymax])
plt.legend()
plt.show()
def plot_overlap(cue, key):
overlaps = file_handling.load_evolution(cue, 0, key)
print(overlaps)
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo,
cm, a, U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0,
g, random_seed, p_0, n_p, nSnap, russo2008_mode, _) = \
file_handling.load_parameters(key)
tS = np.linspace(0, tSim, nSnap)
# plt.title(r"$a_{pf}$=%.2f, $w$=%.1f, $g_A$=%.1f" % (a_pf, w, g_A))
ax.set_title(r"$w$=%.1f, $a_{pf}$=%.2f" % (w, a_pf))
# retrieved = file_handling.load_retrieved(0, key)[0]
# trans_time = file_handling.load_transition_time(0, key)[0]
# for ind_trans in range(len(trans_time)-1):
# ax.text((trans_time[ind_trans+1]+trans_time[ind_trans])/2, 0.9, str(retrieved[ind_trans]), fontsize=15)
ax.plot(tS, overlaps)
def trio_prob_table(retrieved):
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo,
cm, a, U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0,
g, random_seed, p_0, n_p, nSnap, russo2008_mode, muted_prop) = \
file_handling.load_parameters(key)
n_seeds = len(retrieved)
num_ABA = np.zeros((p, p), dtype=int)
num_AB = num_ABA.copy()
num_B = np.zeros(p, dtype=int)
p_B_ABA = np.nan * np.ones((p, p), dtype=float)
p_AB_ABA = np.nan * np.ones((p, p), dtype=float)
p_B = np.nan * np.ones(p, dtype=float)
for kick_seed in range(n_seeds):
for cue_ind in range(p):
if len(retrieved[kick_seed][cue_ind]) >= 3:
# print(len(retrieved[kick_seed][cue_ind]))
duration = len(retrieved[kick_seed][cue_ind])
if cue_ind != retrieved[kick_seed][cue_ind][0]:
duration += 1
# ind_max[cue_ind] = duration
sequence = []
if cue_ind != retrieved[kick_seed][cue_ind][0]:
sequence.append(cue_ind)
sequence += retrieved[kick_seed][cue_ind]
sequence = sequence[3:]
for ind_trans in range(len(sequence) - 2):
pattA = sequence[ind_trans]
pattB = sequence[ind_trans + 1]
num_AB[pattA, pattB] += 1
num_B[pattB] += 1
if sequence[ind_trans + 2] == pattA:
num_ABA[pattA, pattB] += 1
p_B = num_B / np.sum(num_B)
occuring_B = num_B != 0
p_B_ABA[:, occuring_B] = num_ABA[:, occuring_B] / num_B[occuring_B]
occuring_AB = num_AB != 0
p_AB_ABA[occuring_AB] = num_ABA[occuring_AB] / num_AB[occuring_AB]
return p_B_ABA, p_AB_ABA, p_B, num_B, num_AB, num_ABA
def find_neighbors(key):
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo, cm, a, U,
w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0, g, random_seed,
p_0, n_p, nSnap, russo2008_mode) = file_handling.load_parameters(key)
graph_all = nx.Graph()
graph_high = nx.Graph()
graph_low = nx.Graph()
num_trans_all = np.zeros((p, p), dtype=int)
num_trans_high = np.zeros((p, p), dtype=int)
num_trans_low = np.zeros((p, p), dtype=int)
retrieved_saved = file_handling.load_retrieved(key)
lamb = file_handling.load_overlap(key)
threshold = median([
lamb[ind_cue][trans] for ind_cue in range(p)
for trans in range(len(lamb[ind_cue]))
])
neighbors = [[] for pat in range(p)]
for cue_ind in range(p):
if len(retrieved_saved[cue_ind][:ind_max[cue_ind]]) >= 3:
# print(len(retrieved_saved[cue_ind]))
duration = len(retrieved_saved[cue_ind])
if cue_ind != retrieved_saved[cue_ind][0]:
duration += 1
# ind_max[cue_ind] = duration
sequence = []
if cue_ind != retrieved_saved[cue_ind][0]:
sequence.append(cue_ind)
sequence += retrieved_saved[cue_ind]
sequence = sequence[3:ind_max[cue_ind]]
for ind_trans in range(len(sequence) - 1):
patt1 = sequence[ind_trans]
patt2 = sequence[ind_trans + 1]
num_trans_all[patt1, patt2] += 1
if lamb[cue_ind][ind_trans + 1] >= threshold:
num_trans_high[patt1, patt2] += 1
else:
num_trans_low[patt1, patt2] += 1
# if True:
if patt2 not in neighbors[patt1]:
neighbors[patt1].append(patt2)
for patt1 in range(p):
for patt2 in range(p):
if patt1 != patt2:
if num_trans_all[patt1, patt2]:
graph_all.add_edge(patt1,
patt2,
weight=num_trans_all[patt1, patt2])
if num_trans_high[patt1, patt2]:
graph_high.add_edge(patt1,
patt2,
weight=num_trans_high[patt1, patt2])
if num_trans_low[patt1, patt2]:
graph_low.add_edge(patt1,
patt2,
weight=num_trans_low[patt1, patt2])
return neighbors, graph_all, num_trans_all, graph_low, num_trans_low, \
graph_high, num_trans_high, threshold
# bins = np.arange(np.min(counters)-0.5, np.max(counters)+1.5, 1)
sns.distplot(counters)
g_A_s = [0., 0.5, 1.]
apf_s = [0., 0.05, 0.1, 0.2]
n_gA = len(g_A_s)
n_apf = len(apf_s)
for ii in range(15):
key = simulations[ii]
print(ii)
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo,
cm, a, U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0,
g, random_seed, p_0, n_p, nSnap, russo2008_mode) = \
file_handling.load_parameters(key)
if a_pf <= 0.3:
ind_gA = [i for i in range(len(g_A_s)) if g_A_s[i] == g_A][0]
ind_apf = [i for i in range(len(apf_s)) if apf_s[i] == a_pf][0]
neighbors, graph_all, num_trans_all, graph_low, num_trans_low, \
graph_high, num_trans_high, threshold = find_neighbors(key)
# plt.figure('Neighbors_count')
# plt.subplot(2, 2, ind_apf+1)
# count_neighbors(neighbors)
# plt.title(r"$a_{pf}$=%.2f" % a_pf)
# plt.xlabel('Number of neighbors')
# plt.ylabel('Density')
# plt.tight_layout()
retrieved = file_handling.load_retrieved_several(n_seeds, key)
num_tables, proba_tables = proba_tools.build_trans_tables(retrieved, key, L)
alpha = 1
p_min = 1e-3
g_min = 9e-4
alpha = 17.5
r = 1.6
(dt, tSim, N, S, p, num_fact, p_fact,
dzeta, a_pf,
eps,
f_russo, cm, a, U, w, tau_1, tau_2, tau_3_A,
tau_3_B, g_A,
beta, tau, t_0, g, random_seed, p_0, n_p, nSnap,
russo2008_mode, muted_prop) = file_handling.load_parameters(simulations[0])
Y = 0
relevant_seq = [[] for order in range(0, L)]
relevant_seq[0] = [[Y]]
for order in range(2, L):
for ind_XYZ in range(num_tables[order].coords.shape[1]):
XYZ = num_tables[order].coords[:, ind_XYZ]
X = XYZ[0]
Z = XYZ[-1]
Y = XYZ[1:-1]
XY = XYZ[:-1]
YZ = XYZ[1:]
p_XY = proba_tables[order-1][tuple(XY)]
def compare_mi_crossover(simulation_list):
mi_high_s = np.zeros(len(simulation_list))
mi_low_s = mi_high_s.copy()
shuffled_high_s = mi_high_s.copy()
shuffled_low_s = mi_high_s.copy()
random_low_s = mi_high_s.copy()
random_high_s = mi_high_s.copy()
similarity_s = mi_high.copy()
similarity_shuf_s = mi_high.copy()
w_s = mi_high_s.copy()
g_A_s = mi_high_s.copy()
threshold_s = mi_high_s.copy()
for ind_sim in range(len(simulation_list)):
simulation = simulation_list[ind_sim]
retrieved_saved = file_handling.load_retrieved(simulation)
lamb = file_handling.load_overlap(simulation)
print('Events %d' % event_counter(lamb))
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo, cm, a,
U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0, g,
random_seed, p_0, n_p, nSnap,
russo2008_mode) = file_handling.load_parameters(simulation)
lamb_list = [
lamb[ind_cue][ind_trans] for ind_cue in range(len(lamb))
for ind_trans in range(2,
len(lamb[ind_cue]) - 1)
]
# print(lamb_list[:10])
threshold = median(lamb_list)
print(threshold)
mi_high, mi_low, shuffled_high, shuffled_low, random_high, random_low = \
get_mi_crossovers(retrieved_saved, lamb, threshold)
print(mi_high)
mi_high_s[ind_sim] = mi_high
mi_low_s[ind_sim] = mi_low
shuffled_high_s[ind_sim] = shuffled_high
shuffled_low_s[ind_sim] = shuffled_low
random_low_s[ind_sim] = random_high
random_high_s[ind_sim] = random_low
w_s[ind_sim] = w
g_A_s[ind_sim] = g_A
threshold_s[ind_sim] = threshold
ax1 = plt.subplot2grid((3, 2), (0, 0), colspan=2, rowspan=2)
ax1.plot(g_A_s, mi_high_s - shuffled_high_s, 'b-o', label='Corrected high')
ax1.plot(g_A_s, mi_low_s - shuffled_low_s, 'g-o', label='Corrected low')
ax1.plot(g_A_s, mi_high_s, ':b', label='Original high')
ax1.plot(g_A_s, mi_low_s, ':g', label='Original how')
ax1.plot(g_A_s, shuffled_high_s, '--b', label='Bias high')
ax1.plot(g_A_s, shuffled_low_s, '--g', label='Bias low')
ax1.set_ylabel('Mutual information in pairs (m=2)')
ax1.set_xlim(-0.1, 1.1)
ax1.set_title('High-and-low-crossover mutual information')
ax1.legend()
ax1.set_xlabel(r'$g_A$')
ax2 = plt.subplot2grid((3, 2), (2, 0))
ax2.plot(g_A_s, w_s, '-o')
ax2.set_xlim(-0.1, 1.1)
ax2.set_xlabel(r'$g_A$')
ax2.set_ylabel(r'$w$')
ax2.set_ylim(0.9, 1.5)
ax2.set_title('Latching border')
ax3 = plt.subplot2grid((3, 2), (2, 1))
ax3.plot(g_A_s, threshold_s, '-o')
ax3.set_xlim(-0.1, 1.1)
ax3.set_xlabel(r'$g_A$')
ax3.set_ylabel(r'$\lambda$')
ax3.set_ylim(0, 1)
ax3.set_title('Crossover threshold')
plt.tight_layout()
'001319a7dbc27bb929f6c6d00bc4f08d', '8b27f66e75c7f4f4427bbe59515c6e97',
'7218cda81b1e89d0dfc660c0a18ff912', '03771e780bda036f8f2b8160bf2d85d4'
]
n_seeds = [1 for ii in range(len(simulations))]
color_s = [
'blue', 'orange', 'green', 'red', 'peru', 'red', 'red', 'red', 'red', 'red'
]
ymin = 2**(-6)
ymax = 2**3
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo, cm, a, U, w,
tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0, g, random_seed, p_0, n_p,
nSnap, russo2008_mode,
muted_prop) = file_handling.load_parameters(simulations[0])
min_t = min(tau_1, tau_2, tau_3_A, tau_3_B)
def get_mi(retrieved_saved, number_limiter):
mi_saved = []
m_saved = []
ent_cut = []
ent_shifted = []
event_counter = []
control = []
shuffled = []
auto_corr_s = []
auto_corr_shuff_s = []
m_max = 15
for m in range(1, m_max + 1):
def plot_length_highly_correlated(simulation_list):
for ind_key in range(len(simulation_list)):
print('ind_key = %d' % ind_key)
simulation_key = simulation_list[ind_key]
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo,
cm, a, U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0,
g, random_seed, p_0, n_p, nSnap, russo2008_mode, _) = \
file_handling.load_parameters(simulation_key)
lamb = file_handling.load_crossover(0, simulation_key)
lamb_med = []
for ind_cue in range(p):
lamb_med += lamb[ind_cue][1:]
lamb_med = np.array(lamb_med)
lamb_med = median(lamb_med)
cue_number = len(lamb)
n_min = 1
n_max = 400
# n_max = 10*file_handling.event_counter(lamb, p)/p
duration_bins = np.linspace(n_min, n_max, 100)
# duration_bins = np.logspace(np.log10(n_min), np.log10(n_max), 10)
# duration_x = np.logspace(np.log10(n_min), np.log10(n_max), 200)
lambda_threshold_s = [0.2, 0.25, 0.3, 0.35]
lambda_threshold_s = [0]
print(lamb_med)
n_th = len(lambda_threshold_s)
for ind_th in range(n_th):
threshold = lambda_threshold_s[ind_th]
high_sequence_durations = []
for cue_ind in range(cue_number):
length = 0
for ind_trans in range(len(lamb[cue_ind])):
if lamb[cue_ind][ind_trans] > threshold:
length += 1
elif length != 0:
high_sequence_durations.append(length)
length = 0
if length != 0:
high_sequence_durations.append(length)
high_sequence_durations = np.array(high_sequence_durations)
# smooth = sts.gaussian_kde(np.log10(high_sequence_durations+dt))
# plt.subplot(n_th//2+n_th % 2, 2, ind_th+1)
# smooth_data = smooth(np.log10(duration_x))
# rug_data = np.histogram(high_sequence_durations, bins=duration_bins)[0]
# smooth_data = np.max(rug_data)/np.max(smooth_data)*smooth_data
# plt.plot(duration_x, smooth_data, color=color_s[ind_key])
# plt.hist(high_sequence_durations, alpha=0.3,
# density=False, color=color_s[ind_key])
# sns.kdeplot(high_sequence_durations, cumulative=True, color=color_s[ind_key], label='g_A %.1f, w %.1f' % (g_A, w))
sns.distplot(high_sequence_durations,
color=color_s[ind_key],
label='g_A %.1f' % g_A,
kde_kws={'bw': 1})
plt.xlim(n_min, n_max)
# plt.xscale('log')
for ind_th in range(n_th):
# plt.subplot(n_th//2+n_th % 2, 2, ind_th+1)
plt.xlabel('Length')
plt.ylabel('Density')
# plt.xscale('log')
plt.yscale('log')
# plt.title(
# r'$\lambda_{th}$='+str(lambda_threshold_s[ind_th])+',$w$='+str(w))
# plt.subplot(n_th//2+n_th % 2, 1, 1)
plt.legend()
# plt.tight_layout(rect=[0, 0.03, 1, 0.95])
plt.tight_layout()
plt.show()
# # '50a7e2e50bf9b00dff6cd257844d51f7',
# # '2a123a981c3e2871ff8ff30383ecca93'] # w=1.3
simulations_above = [
'12257f9b2af7fdeaa5ebeec24b71b13c', '2999e6e4eede18f9212d8abdd146e7f4',
'779e267d7fd11b394a96bc18ac9d2261'
] # Just above the border
color_s = ['blue', 'orange', 'green']
ymin = 2**(-6)
ymax = 2**3
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo, cm, a, U, w,
tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0, g, random_seed, p_0, n_p,
nSnap, russo2008_mode) = file_handling.load_parameters(simulations_above[0])
min_t = min(tau_1, tau_2, tau_3_A, tau_3_B)
def get_mi(retrieved_saved, number_limiter):
mi_saved = []
m_saved = []
ent_cut = []
ent_shifted = []
event_counter = []
control = []
shuffled = []
m_max = 10
for m in range(1, m_max + 1):
# print('m = %d' % m)
seq_cut = []
plt.close('all')
simulations = [
'83058b3d6f4ce563cecce654468e59ec', '5fde28fc139c3252f8d52b513c7b2364',
'6211c3984769aa0bde863c1fa97be8ef', '3ae4c5af2e17c42b644210bae0c6c88b',
'f7fbf477d959473b676fd5e53a243e51', '0235947fe67f095afdce360a44932aa7',
'3f9349f4d58a0590c6575920163dbd45', '252c00a8ee9a6dbb553e7166d460b4fe',
'06381599d71447f5c7c667e3e3106f88', 'e668a8d56be4b85ea0fe063c0511c617',
'494a1f3016417558967fc452e83604b0', '5c135a6e2604d153a91e4fd757218b49',
'12a26501a9dd07618c85bd6f324237ed', '1d13122682b8d57568e86741055d953b',
'f61c95aad79795bbe476c2a6692025d5'
]
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo, cm, a, U, w,
tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0, g, random_seed, p_0, n_p,
nSnap, russo2008_mode) = file_handling.load_parameters(simulations[0])
def trio_prob_table(retrieved_saved, key):
(dt, tSim, N, S, p, num_fact, p_fact, dzeta, a_pf, eps, f_russo,
cm, a, U, w, tau_1, tau_2, tau_3_A, tau_3_B, g_A, beta, tau, t_0,
g, random_seed, p_0, n_p, nSnap, russo2008_mode) = \
file_handling.load_parameters(key)
num_ABA = np.zeros((p, p), dtype=int)
num_AB = num_ABA.copy()
num_B = np.zeros(p, dtype=int)
p_B_ABA = np.zeros((p, p), dtype=float)
p_AB_ABA = np.zeros((p, p), dtype=float)
p_B = np.zeros(p, dtype=float)
