ax_surface = pt.gcf().add_subplot(2,1,1,projection="3d")
ax_surface.plot_surface(X_surface, Y_surface, L, linewidth=0, antialiased=False, color='gray')
# Set up fiber arguments
# v = 0.*np.ones((2,1)) + 1*np.random.randn(2,1)
v = 20*np.random.rand(2,1) - 10
c = f(v)
c = c + 0.1*np.random.randn(2,1)
fiber_kwargs = {
"f": f,
"ef": ef,
"Df": Df,
"compute_step_amount": lambda trace: (0.001, 0, False),
"v": v,
"c": c,
"logger": lu.Logger(sys.stdout),
"max_step_size": 1,
"terminate": lambda trace: (np.fabs(trace.x[:-1]) > 100).any(),
"max_traverse_steps": 20000,
"max_solve_iterations": 2**5,
}
# Run in one direction
solution = sv.fiber_solver(**fiber_kwargs)
V1 = np.concatenate(solution["Fiber trace"].points, axis=1)[:-1,::10]
FX1 = solution["Fixed points"]
z = solution["Fiber trace"].z_initial
print("Status: %s\n"%solution["Fiber trace"].status)
# Run in other direction (negate initial tangent)
fiber_kwargs["z"] = -z
def run_trials(args):
basename, proc, N, timeout = args
# Reseed randomness, start logging, start timing
np.random.seed()
logfile = open("%s_p%d_N%d.log" % (basename, proc, N), "w")
logger = lu.Logger(logfile)
stop_time = time.clock() + timeout
# Keep sampling until timeout
for sample in it.count(0):
# Sample new network
f, Df, ef, W, V = rnn.make_known_fixed_points(N)
dups = rnn.duplicates_factory(W)
results = {}
data = {"W": W}
# Keep fiber-solving until some c finds all V or timeout
for trial in it.count(0):
print("proc %d, N %d, sample %d, trial %d" %
(proc, N, sample, trial))
# Run fiber solver
start_time = time.clock()
fxpts, solution = rnn.run_fiber_solver(
W,
# max_traverse_steps = 2**15,
stop_time=stop_time,
logger=logger.plus_prefix("(%d,%d,%d): " % (N, sample, trial)))
run_time = time.clock() - start_time
# Update union of fxpts
V = fx.sanitize_points(
np.concatenate((fxpts, V), axis=1),
f,
ef,
Df,
duplicates=dups,
)
# Save results
trace = solution["Fiber trace"]
results[trial] = {
"status": trace.status,
"seconds": run_time,
"|fxpts|": fxpts.shape[1],
"|V|": V.shape[1],
}
results["trials"] = trial + 1
data[str((trial, "c"))] = trace.c
data[str((trial, "fxpts"))] = fxpts
data["V"] = V
sample_basename = "%s_p%d_N%d_s%d" % (basename, proc, N, sample)
with open(sample_basename + ".pkl", 'w') as rf:
pk.dump(results, rf)
with open(sample_basename + ".npz", 'w') as df:
np.savez(df, **data)
print("%d,%d,%d,%d: status %s, |fxpts|=%d, |V|=%d" %
(proc, N, sample, trial, trace.status, fxpts.shape[1],
V.shape[1]))
# Done if current c found full union
if fxpts.shape[1] == V.shape[1]: break
# Done if timeout
if time.clock() > stop_time: break
print("%d,%d,%d: %d trials" % (proc, N, sample, trial + 1))
if time.clock() > stop_time: break
proc_basename = "%s_p%d_N%d" % (basename, proc, N)
with open(proc_basename + ".pkl", 'w') as rf:
pk.dump({"num_samples": sample + 1}, rf)
logfile.close()
ef=ef_factory(W),
Df=Df_factory(W),
duplicates=duplicates_factory(W),
)
# Return post-processed fixed points and full solver result
return fxpts, solution
if __name__ == "__main__":
# Set up 2D network
N = 2
W = 1.25 * np.eye(N) + 0.1 * np.random.randn(N, N)
logger = lu.Logger(sys.stdout)
fxpts, solution = run_fiber_solver(
W,
# max_history=100,
compute_step_amount=compute_step_amount_factory3(W),
logger=logger,
abs_alpha_min=True,
within_fiber=True)
# Extract steps along fiber and corresponding f(v)'s
trace = solution["Fiber trace"]
X = np.concatenate(trace.points, axis=1)
X = np.concatenate((-np.fliplr(X), X), axis=1)
V = X[:-1, :]
# Plot fiber and fixed points
def run_trial(args):
basename, sample, timeout = args
stop_time = time.clock() + timeout
logfile = open("%s_s%d.log" % (basename, sample), "w")
# Set up fiber arguments
np.random.seed()
v = 20 * np.random.rand(2, 1) - 10 # random point in domain
c = lv.f(v) # direction at that point
c = c + 0.1 * np.random.randn(2, 1) # perturb for more variability
fiber_kwargs = {
"f": lv.f,
"ef": lv.ef,
"Df": lv.Df,
"compute_step_amount": lambda trace: (0.0001, 0),
"v": v,
"c": c,
"stop_time": stop_time,
"terminate": lambda trace: (np.fabs(trace.x[:-1]) > 10).any(),
"max_solve_iterations": 2**5,
}
solve_start = time.clock()
# Run in one direction
solution = sv.fiber_solver(logger=lu.Logger(logfile).plus_prefix("+: "),
**fiber_kwargs)
X1 = np.concatenate(solution["Fiber trace"].points, axis=1)
V1 = solution["Fixed points"]
z = solution["Fiber trace"].z_initial
# print("Status: %s\n"%solution["Fiber trace"].status)
# Run in other direction (negate initial tangent)
solution = sv.fiber_solver(z=-z,
logger=lu.Logger(logfile).plus_prefix("-: "),
**fiber_kwargs)
X2 = np.concatenate(solution["Fiber trace"].points, axis=1)
V2 = solution["Fixed points"]
# print("Status: %s\n"%solution["Fiber trace"].status)
# Join fiber segments
fiber = np.concatenate((np.fliplr(X1), X2), axis=1)
# Union solutions
fxpts = fx.sanitize_points(
np.concatenate((V1, V2), axis=1),
f=lv.f,
ef=lv.ef,
Df=lv.Df,
duplicates=lambda V, v: (np.fabs(V - v) < 10**-6).all(axis=0),
)
# Save results
with open("%s_s%d.npz" % (basename, sample), 'w') as rf:
np.savez(
rf, **{
"fxpts": fxpts,
"fiber": fiber,
"runtime": time.clock() - solve_start
})
logfile.close()
v = np.zeros((N, 1))
# c = np.random.randn(N,1)
c = V.dot(np.random.randn(P, 1)) # span of training data
logfile = sys.stdout
fiber_kwargs = {
"f": f,
"ef": ef,
"Df": Df,
"compute_step_amount": compute_step_amount,
"v": v,
"c": c,
"terminate": lambda trace: (np.fabs(trace.x[:N, :]) > 3).any(),
"max_traverse_steps": 2000,
"max_solve_iterations": 2**5,
"max_history": 1000,
"logger": lu.Logger(logfile)
}
# Run in one direction
solution = sv.fiber_solver(**fiber_kwargs)
V1 = np.concatenate(solution["Fiber trace"].points, axis=1)[:N, :]
V1_fx = solution["Fixed points"]
z = solution["Fiber trace"].z_initial
# Run in other direction (negate initial tangent)
fiber_kwargs["z"] = -z
solution = sv.fiber_solver(**fiber_kwargs)
V2 = np.concatenate(solution["Fiber trace"].points, axis=1)[:N, :]
V2_fx = solution["Fixed points"]
# Join fiber segments and fixed points
def run_trial(args):
basename, N, sample, W, V, timeout = args
logfile = open(trialname(basename,N,sample)+".log", "w")
logger = lu.Logger(logfile)
# Sample network
f = rnn.f_factory(W)
Df = rnn.Df_factory(W)
ef = rnn.ef_factory(W)
# Run fiber solver
solve_logger = logger.plus_prefix("(%d,%d): "%(N,sample))
stop_time = time.clock() + timeout
fxpts, solution = rnn.run_fiber_solver(W,
# max_traverse_steps = 2**15,
stop_time = stop_time,
logger=solve_logger,
abs_alpha_min = True,
within_fiber = True)
status = solution["Fiber trace"].status
# Get pre-refinement sign change candidates
sign_changes = solution["Sign changes"]
refinements = solution["Refinements"]
candidates = np.concatenate( # first refinement fiber point
[refinements[sc].points[0][:-1,:] for sc in sign_changes],
axis = 1)
# Post-process sign change candidates
logger.log("(%d,%d): Sanitizing %d sc points\n"%(
N,sample, 2*candidates.shape[1] + 1))
sign_change_fxpts = fx.sanitize_points(
np.concatenate(
(-candidates, np.zeros((N,1)), candidates),
axis=1),
f, ef, Df,
duplicates = rnn.duplicates_factory(W),
)
# Count union
logger.log("(%d,%d): Sanitizing %d+%d=%d union points\n"%(
N,sample, fxpts.shape[1], sign_change_fxpts.shape[1],
fxpts.shape[1] + sign_change_fxpts.shape[1]))
union_fxpts = fx.sanitize_points(
np.concatenate(
(fxpts, sign_change_fxpts),
axis=1),
f, ef, Df,
duplicates = rnn.duplicates_factory(W),
)
logfile.close()
print("(%d,%d) fxpt counts: new %d, old %d, union %d (status=%s)"%(
N,sample,fxpts.shape[1], sign_change_fxpts.shape[1],
union_fxpts.shape[1], status))
results = {
"status": status,
"new count": fxpts.shape[1],
"old count": sign_change_fxpts.shape[1],
"union": union_fxpts.shape[1],
}
with open(trialname(basename,N,sample)+".pkl",'w') as rf:
pk.dump(results, rf)
def get_solver_kwargs(data,
c=None,
step_size=None,
ef=None,
history=1000,
silent=True):
W = np.matmul(data, data.T)
for i in range(W.shape[0]):
W[i, i] = 0
W *= (1.0 / W.shape[0])
logfile = sys.stdout
fiber_kwargs = {
"f":
lambda v: _f(W, v),
"ef":
ef_factory(W) if ef is None else lambda v: ef * np.ones(
(W.shape[0], 1)), # 1e-6 good default for ef
"Df":
lambda v: _Df(W, v),
"compute_step_amount":
compute_step_amount_factory(W) if step_size is None else lambda trace:
(step_size, 0, 0),
"v":
None, # Just use default - origin
"c":
c,
"N":
data.shape[0],
"terminate":
None, # lambda trace: (np.fabs(trace.x[:N,:]) > 3).any(),
"max_traverse_steps":
2e5 if step_size is None else int(
200 / step_size
), # step size computed is normally in 1e-4 range and 200/1e-4 = 2e6. 2e5 is a compromise
"max_solve_iterations":
2**5,
"max_history":
history,
"logger":
lu.Logger(logfile) if not silent else None
}
# Old kwargs:
# fiber_kwargs = {
# "f": lambda v: _f(W,v),
# "ef": lambda v: 1e-6*np.ones((W.shape[0],1)),
# "Df": lambda v: _Df(W,v),
# "compute_step_amount": lambda trace: (step_size, 0),
# "v": None, # Just use default - origin
# "c": None, # Just use default - random
# "N": data.shape[0],
# "terminate": None,
# #"max_step_size": 1,
# "max_traverse_steps": int(200/step_size),
# "max_solve_iterations": (2**5),
# "max_history": 1000,
# #"solve_tolerance": 10**-10,
# "logger": lu.Logger(logfile) if not silent else None
# }
#
return fiber_kwargs