def turing_erase(n=50000, k=100, p=0.01, beta=0.05, r=1.0, bigger_factor=20):
b = brain.Brain(p, save_winners=True)
# Much smaller stimulus, similar to lower p from stimulus into A
smaller_k = int(r * k)
b.add_stimulus("stim", smaller_k)
b.add_area("A", n, bigger_factor * k, beta)
b.add_area("B", n, bigger_factor * k, beta)
b.add_area("C", n, bigger_factor * k, beta)
b.update_plasticities(area_update_map={
"A": [("B", 0.8), ("C", 0.8), ("A", 0.01)],
"B": [("A", 0.8), ("B", 0.8)],
"C": [("A", 0.8), ("C", 0.8)]
},
stim_update_map={"A": [("stim", 0.05)]})
b.project({"stim": ["A"]}, {})
t = 1
while True:
b.project({"stim": ["A"]}, {"A": ["A"]})
if (b.areas["B"].num_first_winners <=
1) and (b.areas["A"].num_first_winners <= 1):
print("proj(stim, A) stabilized after " + str(t) + " rounds")
break
t += 1
b.project({"stim": ["A"]}, {"A": ["A", "B"]})
t = 1
while True:
b.project({"stim": ["A"]}, {"A": ["A", "B"], "B": ["B", "A"]})
print("Num new winners in A " + str(b.areas["A"].num_first_winners))
if (b.areas["B"].num_first_winners <=
1) and (b.areas["A"].num_first_winners <= 1):
print("recip_project(A,B) stabilized after " + str(t) + " rounds")
break
t += 1
A_after_proj_B = b.areas["A"].winners
b.project({"stim": ["A"]}, {"A": ["A", "C"]})
t = 1
while True:
b.project({"stim": ["A"]}, {"A": ["A", "C"], "C": ["C", "A"]})
print("Num new winners in A " + str(b.areas["A"].num_first_winners))
if (b.areas["C"].num_first_winners <=
1) and (b.areas["A"].num_first_winners <= 1):
print("recip_project(A,C) stabilized after " + str(t) + " rounds")
break
t += 1
A_after_proj_C = b.areas["A"].winners
# Check final conditions
b.project({}, {"A": ["B"]})
B_after_erase = b.areas["B"].saved_winners[-1]
B_before_erase = b.areas["B"].saved_winners[-2]
B_overlap = bu.overlap(B_after_erase, B_before_erase)
print("Overlap of B after erase and with y is " + str(B_overlap) + "\n")
A_overlap = bu.overlap(A_after_proj_B, A_after_proj_C)
print("Overlap of A after proj(B) vs after proj(C) is " + str(A_overlap) +
"\n")
def overlap_grand_sim(n=100000,k=317,p=0.01,beta=0.05,min_iter=10,max_iter=30):
b = brain.Brain(p, save_winners=True)
b.add_stimulus("stimA",k)
b.add_area("A",n,k,beta)
b.add_stimulus("stimB",k)
b.add_area("B",n,k,beta)
b.add_area("C",n,k,beta)
b.add_area("D",n,k,0)
b.project({"stimA":["A"],"stimB":["B"]},{})
# Create assemblies A and B to stability
for i in range(10):
b.project({"stimA":["A"],"stimB":["B"]},
{"A":["A"],"B":["B"]})
b.project({"stimA":["A"]},{"A":["A","C"]})
# Project A->C
for i in range(10):
b.project({"stimA":["A"]},
{"A":["A","C"],"C":["C"]})
# Project B->C
b.project({"stimB":["B"]},{"B":["B","C"]})
for i in range(10):
b.project({"stimB":["B"]},
{"B":["B","C"],"C":["C"]})
# Project both A,B to C
b.project({"stimA":["A"],"stimB":["B"]},
{"A":["A","C"],"B":["B","C"]})
for i in range(min_iter-2):
b.project({"stimA":["A"],"stimB":["B"]},
{"A":["A","C"],"B":["B","C"],"C":["C"]})
results = {}
for i in range(min_iter,max_iter+1):
b.project({"stimA":["A"],"stimB":["B"]},
{"A":["A","C"],"B":["B","C"],"C":["C"]})
b_copy1 = copy.deepcopy(b)
b_copy2 = copy.deepcopy(b)
# in copy 1, project just A
b_copy1.project({"stimA":["A"]},{})
b_copy1.project({},{"A":["C"]})
# in copy 2, project just B
b_copy2.project({"stimB":["B"]},{})
b_copy2.project({},{"B":["C"]})
intersection = bu.overlap(b_copy1.areas["C"].winners, b_copy2.areas["C"].winners)
assembly_overlap = float(intersection)/float(k)
# projecting into D
b_copy1.project({},{"C":["D"]})
b_copy1.project({"stimB":["B"]},{})
b_copy1.project({},{"B":["C"]})
b_copy1.project({},{"C":["D"]})
D_saved_winners = b_copy1.areas["D"].saved_winners
proj_intersection = bu.overlap(D_saved_winners[0], D_saved_winners[1])
proj_overlap = float(proj_intersection)/float(k)
print("t=" + str(i) + " : " + str(assembly_overlap) + " -> " + str(proj_overlap) + "\n")
results[assembly_overlap] = proj_overlap
return results
def overlap_sim(n=100000, k=317, p=0.05, beta=0.1, project_iter=10):
b = brain.Brain(p, save_winners=True)
b.add_stimulus("stimA", k)
b.add_area("A", n, k, beta)
b.add_stimulus("stimB", k)
b.add_area("B", n, k, beta)
b.add_area("C", n, k, beta)
b.add_area("D", n, k, 0.0) # final project test area
b.project({"stimA": ["A"], "stimB": ["B"]}, {})
# Create assemblies A and B to stability
for i in xrange(9):
b.project({"stimA": ["A"], "stimB": ["B"]}, {"A": ["A"], "B": ["B"]})
b.project({"stimA": ["A"]}, {"A": ["A", "C"]})
# Project A->C
for i in xrange(9):
b.project({"stimA": ["A"]}, {"A": ["A", "C"], "C": ["C"]})
# Project B->C
b.project({"stimB": ["B"]}, {"B": ["B", "C"]})
for i in xrange(9):
b.project({"stimB": ["B"]}, {"B": ["B", "C"], "C": ["C"]})
# Project both A,B to C
b.project({
"stimA": ["A"],
"stimB": ["B"]
}, {
"A": ["A", "C"],
"B": ["B", "C"]
})
for i in xrange(project_iter):
b.project({
"stimA": ["A"],
"stimB": ["B"]
}, {
"A": ["A", "C"],
"B": ["B", "C"],
"C": ["C"]
})
# Project just B
b.project({"stimB": ["B"]}, {"B": ["B", "C"]})
# compute overlap
intersection = bu.overlap(b.areas["C"].saved_winners[-1],
b.areas["C"].saved_winners[9])
assembly_overlap = float(intersection) / float(k)
b.project({}, {"C": ["D"]})
# Project just A
b.project({"stimA": ["A"]}, {"A": ["A", "C"]})
b.project({}, {"C": ["D"]})
D_saved_winners = b.areas["D"].saved_winners
proj_intersection = bu.overlap(D_saved_winners[0], D_saved_winners[1])
proj_overlap = float(proj_intersection) / float(k)
return assembly_overlap, proj_overlap
def larger_k(n=10000,k=100,p=0.01,beta=0.05, bigger_factor=10):
b = brain.Brain(p, save_winners=True)
b.add_stimulus("stim", k)
b.add_area("A",n,k,beta)
b.add_area("B",n,bigger_factor*k,beta)
b.update_plasticities(area_update_map={"A":[("B", 0.8), ("A", 0.0)],
"B":[("A", 0.8), ("B", 0.8)]})
b.project({"stim":["A"]},{})
t=1
while True:
b.project({"stim":["A"]},{"A":["A"]})
print("A total w is " + str(b.areas["A"].support_size))
if (b.areas["B"].num_first_winners <= 1) and (b.areas["A"].num_first_winners <= 1):
print("proj(stim, A) stabilized after " + str(t) + " rounds")
break
t += 1
A_after_proj = b.areas["A"].winners
b.project({"stim":["A"]},{"A":["A","B"]})
t=1
while True:
b.project({"stim":["A"]},{"A":["A","B"], "B":["B", "A"]})
print(("Num new winners in A " + str(b.areas["A"].num_first_winners)))
print(("Num new winners in B " + str(b.areas["B"].num_first_winners)))
if (b.areas["B"].num_first_winners <= 1) and (b.areas["A"].num_first_winners <= 1):
print("recip_project(A,B) stabilized after " + str(t) + " rounds")
break
t += 1
print("Final statistics")
print("A.w = " + str(b.areas["A"].support_size))
print("B.w = " + str(b.areas["B"].support_size))
A_after_B = b.areas["A"].saved_winners[-1]
o = bu.overlap(A_after_proj, A_after_B)
print("Overlap is " + str(o))
def pattern_com_iterations(n=100000,
k=317,
p=0.01,
beta=0.05,
alpha=0.4,
comp_iter=8,
min_iter=20,
max_iter=30):
b = brain.Brain(p)
b.add_stimulus("stim", k)
b.add_area("A", n, k, beta)
b.project({"stim": ["A"]}, {})
for i in xrange(min_iter - 2):
b.project({"stim": ["A"]}, {"A": ["A"]})
results = {}
subsample_size = int(k * alpha)
subsample = random.sample(b.areas["A"].winners, subsample_size)
for i in xrange(min_iter, max_iter + 1):
b.project({"stim": ["A"]}, {"A": ["A"]})
b_copy = copy.deepcopy(b)
b_copy.areas["A"].winners = subsample
for j in xrange(comp_iter):
b_copy.project({}, {"A": ["A"]})
o = bu.overlap(b_copy.areas["A"].winners, b.areas["A"].winners)
results[i] = float(o) / float(k)
return results
def pattern_com_alphas(
n=100000,
k=317,
p=0.01,
beta=0.05,
alphas=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0],
project_iter=25,
comp_iter=5):
b = brain.Brain(p)
b.add_stimulus("stim", k)
b.add_area("A", n, k, beta)
b.project({"stim": ["A"]}, {})
for i in xrange(project_iter - 1):
b.project({"stim": ["A"]}, {"A": ["A"]})
results = {}
A_winners = b.areas["A"].winners
for alpha in alphas:
# pick random subset of the neurons to fire
subsample_size = int(k * alpha)
b_copy = copy.deepcopy(b)
subsample = random.sample(b_copy.areas["A"].winners, subsample_size)
b_copy.areas["A"].winners = subsample
for i in xrange(comp_iter):
b_copy.project({}, {"A": ["A"]})
final_winners = b_copy.areas["A"].winners
o = bu.overlap(final_winners, A_winners)
results[alpha] = float(o) / float(k)
return results
def association_grand_sim(n=100000, k=317, p=0.01, beta=0.05, min_iter=10, max_iter=20):
b = brain.Brain(p)
b.add_stimulus("stimA", k)
b.add_area("A", n, k, beta)
b.add_stimulus("stimB", k)
b.add_area("B", n, k, beta)
b.add_area("C", n, k, beta)
b.project({"stimA": ["A"], "stimB": ["B"]}, {})
# Create assemblies A and B to stability
for i in range(9):
b.project({"stimA": ["A"], "stimB": ["B"]},
{"A": ["A"], "B": ["B"]})
b.project({"stimA": ["A"]}, {"A": ["A", "C"]})
# Project A->C
for i in range(9):
b.project({"stimA": ["A"]},
{"A": ["A", "C"], "C": ["C"]})
# Project B->C
b.project({"stimB": ["B"]}, {"B": ["B", "C"]})
for i in range(9):
b.project({"stimB": ["B"]},
{"B": ["B", "C"], "C": ["C"]})
# Project both A,B to C
b.project({"stimA": ["A"], "stimB": ["B"]},
{"A": ["A", "C"], "B": ["B", "C"]})
for i in range(min_iter - 2):
b.project({"stimA": ["A"], "stimB": ["B"]},
{"A": ["A", "C"], "B": ["B", "C"], "C": ["C"]})
results = {}
for i in range(min_iter, max_iter + 1):
b.project({"stimA": ["A"], "stimB": ["B"]},
{"A": ["A", "C"], "B": ["B", "C"], "C": ["C"]})
b_copy1 = copy.deepcopy(b)
b_copy2 = copy.deepcopy(b)
# in copy 1, project just A
b_copy1.project({"stimA": ["A"]}, {})
b_copy1.project({}, {"A": ["C"]})
# in copy 2, project just B
b_copy2.project({"stimB": ["B"]}, {})
b_copy2.project({}, {"B": ["C"]})
o = bu.overlap(b_copy1.areas["C"].winners, b_copy2.areas["C"].winners)
results[i] = float(o) / float(k)
return results
