-
Notifications
You must be signed in to change notification settings - Fork 0
/
run.py
158 lines (142 loc) · 4.49 KB
/
run.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
import pickle
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import matplotlib.cm as cm
import matplotlib.gridspec as gridspec
from math import pi
from math import sin
from math import cos
from PlotMaker import PlotMaker
from Network import OverlapNetwork
from LearningNetwork import LearningNetwork
from IsolatedNetwork import IsolatedNetwork
from Simulator import Simulator
from Input import BehavioralInput, NavigationInput
from Input import OneCacheInput, MultiCacheInput, PresentationInput
pm = PlotMaker()
def run_and_plot_presentation(overlap=0.):
""" Runs and plots the hand-tuned network. """
N_pl = 100
N_ep = 104
K_ep = 0.8
K_pl = 0.
network = OverlapNetwork(
N_pl=N_pl, N_ep=N_ep, K_pl=K_pl, K_ep=K_ep, overlap=overlap,
add_feedback=True, num_internetwork_connections=2, num_ep_modules=8
)
inputgen = PresentationInput(
pre_seed_locs=[pi/2, 3*pi/2], K_pl=K_pl, K_ep=K_ep
)
sim = Simulator(network, inputgen)
m, f = sim.simulate()
pm.plot_main(sim, f)
pm.plot_J(sim)
with open("presentationnet.p", "wb") as p:
pickle.dump({"sim": sim, "m": m, "f": f}, p)
def run_and_plot_overlapnet(overlap=0.):
""" Runs and plots the hand-tuned network. """
N_pl = 100
N_ep = 100
K_ep = 0.8
K_pl = 0.2
network = OverlapNetwork(
N_pl=N_pl, N_ep=N_ep, K_pl=K_pl, K_ep=K_ep, overlap=overlap,
add_feedback=True, num_internetwork_connections=3, num_ep_modules=7
)
inputgen = BehavioralInput(pre_seed_loc=7, K_pl=K_pl, K_ep=K_ep)
sim = Simulator(network, inputgen)
m, f = sim.simulate()
pm.plot_main(sim, f)
pm.plot_J(sim)
with open("overlapnet.p", "wb") as p:
pickle.dump({"sim": sim, "m": m, "f": f}, p)
def run_and_plot_learningring(overlap=0., network=None):
""" Runs and plots a random network learning the ring structure. """
N = 104
K_inhib = 0.6
if network is None:
network = IsolatedNetwork(N, K_inhib, "wta", 8)
else:
with open(network, "rb") as p:
dic = pickle.load(p)
network = dic["sim"].network
inputgen = NavigationInput(T=10000) # 13000
sim = Simulator(network, inputgen)
pm.plot_J(sim)
m, f = sim.simulate()
pm.plot_main(sim, f)
pm.plot_J(sim)
with open("learnedring.p", "wb") as p:
pickle.dump({"sim": sim}, p)
def run_and_plot_learningassociations(overlap=0.):
"""
Runs and plots a place and episode network learning inter-network
connections.
"""
N_pl = 100
N_ep = 100
K_pl = K_ep = 0.3
network = LearningNetwork(
N_pl=N_pl, N_ep=N_ep, K_pl=K_pl, K_ep=K_ep, overlap=overlap,
num_wta_modules=9, start_random=False, start_wta=False
)
inputgen = MultiCacheInput(K_ep=K_ep)
sim = Simulator(network, inputgen)
pm.plot_J(sim)
m, f = sim.simulate()
pm.plot_main(sim, f)
pm.plot_J(sim)
def run_and_plot_endtoend(overlap=0.):
""" Runs and plots the end-to-end learning process """
#np.random.seed(0)
N_pl = 104
N_ep = 104
K_pl = K_ep = 0.6 #0.5 TODO
network = LearningNetwork(
N_pl=N_pl, N_ep=N_ep, K_pl=K_pl, K_ep=K_ep, overlap=overlap,
num_wta_modules=8, start_random=False, start_wta=True
)
inputgen = NavigationInput(T=22000) # 18000 TODO
sim1 = Simulator(network, inputgen)
pm.plot_J(sim1)
m, f = sim1.simulate()
sim1.m = m
sim1.f = f
pm.plot_main(sim1, f)
pm.plot_J(sim1)
inputgen = OneCacheInput(K_ep=K_ep)
sim2 = Simulator(network, inputgen)
m, f = sim2.simulate()
sim2.m = m
sim2.f = f
pm.plot_main(sim2, f)
pm.plot_J(sim2)
inputgen = PresentationInput(
pre_seed_locs=[pi/4, 3*pi/2], K_pl=K_pl, K_ep=K_ep
)
sim3 = Simulator(network, inputgen)
m, f = sim3.simulate()
pm.plot_main(sim3, f)
pm.plot_J(sim3)
with open("learnednet.p", "wb") as p:
pickle.dump({
"sim1": sim1, "sim2": sim2, "sim3": sim3, "m": m, "f": f
}, p)
import pdb; pdb.set_trace()
def test_net(p):
with open(p, "rb") as p:
dic = pickle.load(p)
network = dic["sim"].network
K_pl = network.K_pl
K_ep = network.K_ep
inputgen = BehavioralInput(pre_seed_loc=13, K_pl=K_pl, K_ep=K_ep)
sim = Simulator(network, inputgen)
m, f = sim.simulate()
pm.plot_main(sim, f)
pm.plot_J(sim)
def main():
for o in [0.]: # TODO
print("Overlap: %1.2f"%o)
run_and_plot_learningring()
main()