class GridRateParams: # gaugrid small arena gau_grid_small_arena_biphasic_neg = map_merge(def_gau_grid_small_arena_sigma_large,filter_biphasic_neg) gau_grid_small_arena_biphasic_pos = map_merge(def_gau_grid_small_arena_sigma_small,filter_biphasic_pos) # gaugrid large arena gau_grid_large_arena_biphasic_neg = map_merge(def_gaugrid_large_arena_sigma_large,filter_biphasic_neg) gau_grid_large_arena_biphasic_pos = map_merge(def_gaugrid_large_arena_sigma_small,filter_biphasic_pos) # gaumix small arena gau_mix_small_arena_biphasic_neg = map_merge(def_gaumix_small_arena_sigma_large,filter_biphasic_neg) gau_mix_small_arena_biphasic_pos = map_merge(def_gaumix_small_arena_sigma_small,filter_biphasic_pos)
from grid_const import ModelType
import plotlib as pp
from grid_batch import GridBatch
from simlib import run_from_ipython
from grid_inputs import GridInputs
from simlib import ensureDir
figures_path = '../figures'
ensureDir(figures_path)
force = False
batch_default_map = map_merge(GridRateParams.gau_mix_small_arena_biphasic_neg,
{
'dt': 10.,
'compute_scores': False,
})
p = get_params(batch_default_map)
batch_override_map = {'inputs_seed': np.arange(100)}
batch = GridBatch(ModelType.MODEL_RATE_AVG,
batch_default_map,
batch_override_map,
force=force)
do_run = batch.post_init()
if (force or do_run) and not run_from_ipython():
batch.run()
batch.post_run()
n = 60
num_gau_mix_ran = np.arange(2, 24, 2)
all_mean_pw_profs = []
all_mean_pw_profs_norm = []
all_teonum_scale_factors = []
all_num_eigs = []
all_teo_eigs = []
for num_gau_mix in num_gau_mix_ran:
param_map = map_merge(GridRateParams.gau_mix_small_arena_biphasic_neg, {
'num_gau_mix': num_gau_mix,
'n': n,
'inputs_seed': inputs_seed
})
p = get_params(param_map)
inputs = GridInputs(
param_map,
keys_to_load=['in_freqs', 'in_mean_pw_profile', 'random_amps'])
in_freqs = inputs.in_freqs
corr = GridCorrSpace(param_map, keys_to_load=['eigs', 'CC_teo'])
num_eigs = np.real(np.linalg.eigvals(corr.CC_teo -
np.diag([p.a] * p.n**2)))
all_num_eigs.append(num_eigs)
eigs_freqs, teo_eigs = compute_teo_eigs(inputs,
import os
from grid_const import ModelType
from grid_functions import map_merge
from grid_params import GridSpikeParams
from grid_batch import GridBatch
from simlib import ensureDir
figures_path = '../figures'
ensureDir(figures_path)
#%%
######################## MULTILPLE LEARNING RATES ###################################
learn_rates = [2e-5, 3e-5, 5e-5, 1e-4]
batch_default_map = map_merge(
GridSpikeParams.gau_grid_small_arena_biphasic_neg, {'a': 1.1})
# time vector
num_sim_steps = int(batch_default_map['sim_time'] / batch_default_map['dt'])
delta_snap = int(num_sim_steps / batch_default_map['num_snaps'])
snap_times = np.arange(
batch_default_map['num_snaps']) * delta_snap * batch_default_map['dt']
pl.rc('font', size=13)
pp.set_tick_size(4)
fig = pl.figure(figsize=(8, 3), facecolor='w')
ax1 = pl.subplot(1, 2, 1)
ax2 = pl.subplot(1, 2, 2)
pl.subplots_adjust(bottom=0.2, wspace=0.4, left=0.1, right=0.97)
def post_init(self, force_gen_inputs=False):
self.startClock = clock()
self.startTime = datetime.datetime.fromtimestamp(time.time())
self.startTimeStr = self.startTime.strftime('%Y-%m-%d %H:%M:%S')
self.dx = self.L / self.nx
X, Y = np.mgrid[-self.L / 2:self.L / 2:self.dx,
-self.L / 2:self.L / 2:self.dx]
self.pos = np.array([np.ravel(X), np.ravel(Y)]).T
if self.filter_type == FilterType.FILTER_INPUT:
self.b1 = 1. / self.tau1
self.b2 = 1. / self.tau2
self.b3 = 1. / self.tau3
elif self.filter_type == FilterType.FILTER_OUTPUT:
self.b_in = 1. / self.tau_in
self.b_out = 1. / self.tau_out
self.N = self.n**2
# number of samples for the filter
self.tau_samps = 2**8 + 1
self.tau_ran = np.arange(self.tau_samps) * self.dx
if self.filter_type == FilterType.FILTER_INPUT:
self.K_samp = K_t(self.b1, self.b2, self.b3, self.mu1, self.mu2,
self.mu3, self.tau_ran / self.speed) / self.speed
elif self.filter_type == FilterType.FILTER_OUTPUT:
self.K_samp = K_outeq_t(self.b_in, self.b_out, self.mu_out,
self.tau_ran / self.speed) / self.speed
tapered = False
if hasattr(self, 'tap_inputs') and self.tap_inputs is True:
tapered = True
# for Gaussian periodic we just compute analytically
if self.inputs_type == InputType.INPUT_GAU_GRID \
and self.use_theory is True and tapered is False:
self.compute_analytically = True
print 'Analytical estimation for Gaussian receptive fields (%s)' % (
'periodic' if self.periodic_inputs else 'non periodic')
ran, step = np.linspace(-self.L / 2.,
self.L / 2.,
self.n,
endpoint=False,
retstep=True)
SSX, SSY = np.meshgrid(ran, ran)
self.centers = np.array([np.ravel(SSX), np.ravel(SSY)]).T
self.amp = self.input_mean * self.L**2 / (2 * np.pi *
self.sigma**2)
else:
print 'Numerical estimation for general inputs'
self.compute_analytically = False
# load inputs
self.inputs = GridInputs(self.__dict__, force_gen=force_gen_inputs)
self.inputs_flat = self.inputs.inputs_flat
self.inputs_path = self.inputs.dataPath
# parameters map
self.paramMap = {
'id': self.id,
'L': self.L,
'n': self.n,
'speed': self.speed,
'nx': self.nx,
'sigma': self.sigma,
'input_mean': self.input_mean,
'periodic_inputs': self.periodic_inputs,
'inputs_type': self.inputs_type
}
if self.filter_type == FilterType.FILTER_INPUT:
self.paramMap = map_merge(
self.paramMap, {
'tau1': self.tau1,
'tau2': self.tau2,
'tau3': self.tau3,
'mu1': self.mu1,
'mu2': self.mu2,
'mu3': self.mu3,
'b1': self.b1,
'b2': self.b2,
'b3': self.b3
})
elif self.filter_type == FilterType.FILTER_OUTPUT:
self.paramMap = map_merge(
self.paramMap, {
'tau_in': self.tau_in,
'tau_out': self.tau_out,
'mu_out': self.mu_out,
'b_in': self.b_in,
'b_out': self.b_out
})
class GridSpikeParams: gau_grid_small_arena_biphasic_neg=map_merge(def_spikes_sigma_large,filter_biphasic_neg) gau_grid_small_arena_biphasic_pos=map_merge(def_spikes_sigma_small,filter_biphasic_pos)
import numpy as np
import pylab as pl
import plotlib as pp
import os
from grid_functions import load_data, compute_teo_eigs, compute_gaussian_teo_corr, map_merge
from grid_spikes import GridSpikes
from grid_params import GridSpikeParams
import gridlib as gl
from simlib import ensureDir
figures_path = '../figures'
ensureDir(figures_path)
par_map = map_merge(GridSpikeParams.gau_grid_small_arena_biphasic_neg, {
'a': 1.1,
'seed': 30,
'variable_speed': False,
})
sim = GridSpikes(par_map)
sim.post_init()
# generate results of the spiking model if not present
if not os.path.exists(sim.dataPath):
sim.run()
sim.post_run()
# load data
p, r = load_data(
os.path.join(GridSpikes.results_path, '%s_data.npz' % sim.hash_id))
'up_bound':1.,
'J0_std':1e-4,
'r0':10.,
# STDP
'Aplus' : 10.,
'Aminus' : 10.,
'tau_plus' : 0.05,
'tau_minus' : 0.05,
'compute_scores':True,
}
def_spikes_sigma_large=map_merge(def_spikes,
{
'sigma':0.0625,
'input_mean':0.4,
'a':1.0
})
def_spikes_sigma_small=map_merge(def_spikes,
{
'sigma':0.04,
'input_mean':0.2,
'a':5.0
})
#### RATE
def_rate ={
def post_init(self, do_print=False):
if not self.force and not self.force_gen_inputs and os.path.exists(
self.dataPath):
if do_print:
print 'Data hash %s already present' % self.hash_id
return False
seed(self.seed)
self.sigmas_per_dx = self.sigma * self.n / self.L
self.num_sim_steps = int(self.sim_time / self.dt)
self.position_dt_scale = int(self.position_dt / self.dt)
self.startClock = clock()
self.startTime = datetime.datetime.fromtimestamp(time.time())
self.startTimeStr = self.startTime.strftime('%Y-%m-%d %H:%M:%S')
if self.filter_type == FilterType.FILTER_INPUT:
# inverse filter time constants
self.b1 = 1 / self.tau1
self.b2 = 1 / self.tau2
self.b3 = 1 / self.tau3
# integral of the filter
self.K_int = self.mu1 + self.mu2 + self.mu3
else:
self.b_in = 1. / self.tau_in
self.b_out = 1. / self.tau_out
self.K_int = np.real(
K_outeq_ft_k(self.b_in, self.b_out, self.mu_out, 0.))
# total number of neurons and density
self.N = self.n**2
self.rho = self.N / self.L**2
# mean input and mean correlation
self.C_av = self.input_mean**2 * self.K_int
# compute normalization time constant
self.tau_av = 1. / (self.eta *
(self.a - self.N *
(self.C_av - self.input_mean * self.gamma)))
# computa B,alpha,beta from a, J_av_target
self.B = self.J_av_target / (self.eta * self.tau_av)
self.alpha = self.a / self.input_mean
self.beta = self.B / self.input_mean - self.r0
self.J_av_star = self.B * self.eta * self.tau_av
# derived quantities
self.k1 = self.input_mean * (self.r0 + self.beta)
self.k2 = self.input_mean * self.gamma
self.k3 = self.input_mean * self.alpha
# load input data
self.inputs = GridInputs(self.initParamMap,
do_print=do_print,
force_gen=self.force_gen_inputs)
self.inputs_path = self.inputs.dataPath
self.inputs_flat = self.inputs.inputs_flat
if self.inputs_type == InputType.INPUT_GAU_GRID:
self.amp = self.inputs.amp
else:
self.amp = np.NaN
# compute eigenvalues
self.freqs, self.raw_eigs = compute_teo_eigs(self.inputs,
self.__dict__,
teo_input_pw=False)
self.raw_eigs[
0] = self.raw_eigs[0] - self.N * self.gamma * self.input_mean
self.max_eig_idx = self.raw_eigs.argmax()
self.max_freq = self.freqs[self.max_eig_idx]
self.eigs_lf_diff = (self.raw_eigs[self.max_eig_idx] -
self.raw_eigs[self.max_eig_idx - 1])
self.eigs_hf_diff = (self.raw_eigs[self.max_eig_idx] -
self.raw_eigs[self.max_eig_idx + 1])
self.eigs = self.raw_eigs - self.a
self.max_eig = self.eigs.max()
self.eig0 = self.eigs[0]
self.tau_str = 1. / (self.eta * self.max_eig)
# load walk data
self.walk = GridWalk(self.__dict__, do_print=do_print)
self.walk_path = self.walk.dataPath
self.pos = self.walk.pos
self.pidx_vect = self.walk.pidx_vect
self.nx = self.walk.nx
self.walk_steps = self.walk.walk_steps
# output rate normalization
self.r_out_star = (self.input_mean * self.K_int -
self.gamma) * self.J_av_star * self.N + self.r0
# compute boundary input
if self.add_boundary_input is True:
self.boundary_input_flat = self.r_out_star - self.get_estimated_output(
np.ones(self.N) * self.J_av_star, 0)
else:
self.boundary_input_flat = np.zeros(self.nx**2)
# initial weights
self.J0_mean = self.J_av_star * self.J0_mean_factor
# exponential distribution
if self.J0_dist == DistType.J0_EXP:
self.J0 = exponential(self.J0_mean, self.N)
# normal distribution
elif self.J0_dist == DistType.J0_NORM:
self.J0 = np.ones(self.N) * self.J0_mean + randn(
self.N) * self.J0_std
self.J0 = self.J0 / np.mean(self.J0) * self.J0_mean
# exponential distribution with half of the weights set to zero
elif self.J0_dist == DistType.J0_HALF_EXP:
self.J0 = np.zeros(self.N)
non_zero_idxs = permutation(self.N)[0:self.N / 2]
self.J0[non_zero_idxs] = exponential(self.J_av_star * 2,
self.N / 2)
self.J0 = self.J0 / self.J0.mean() * self.J_av_star
np.clip(self.J0, 0, self.up_bound, out=self.J0)
self.delta_snap = int(
np.floor(float(self.num_sim_steps) / (self.num_snaps)))
assert (self.delta_snap > 0)
self.derived_param_str = 'amp=%.1f max_eig=%.2f max_freq=%.1f tau_av=%.1e tau_str=%1.e\
eigs_lf_diff=%.3f eigs_hf_diff=%.3f' \
%(self.amp,self.max_eig,self.max_freq,self.tau_av,self.tau_str,self.eigs_lf_diff,self.eigs_hf_diff)
self.summary_str = """
HASH: %s
KEY PARAMS: %s
INPUT PARAMS: %s
WALK PARAMS: %s
DERIVED PARAMS: %s
""" % (self.hash_id, self.key_params_str, self.input_params_str,
self.walk_params_str, self.derived_param_str)
# derived parameters map
self.derivedParamMap = {
'hash_id': self.hash_id,
'N': self.N,
'amp': self.amp,
'rho': self.rho,
'sigmas_per_dx': self.sigmas_per_dx,
'num_sim_steps': self.num_sim_steps,
'delta_snap': self.delta_snap,
'k1': self.k1,
'k2': self.k2,
'k3': self.k3,
'K_int': self.K_int,
'B': self.B,
'alpha': self.alpha,
'beta': self.beta,
'C_av': self.C_av,
'J_av_star': self.J_av_star,
'tau_av': self.tau_av,
'r_out_star': self.r_out_star,
'J0_mean': self.J0_mean,
'max_eig': self.max_eig,
'max_freq': self.max_freq,
'tau_str': self.tau_str,
'eig0': self.eig0,
'eigs_lf_diff': self.eigs_lf_diff,
'eigs_hf_diff': self.eigs_hf_diff,
'summary_str': self.summary_str
}
if self.filter_type == FilterType.FILTER_INPUT:
self.derivedParamMap = map_merge(self.derivedParamMap, {
'b1': self.b1,
'b2': self.b2,
'b3': self.b3
})
else:
self.derivedParamMap = map_merge(self.derivedParamMap, {
'b_in': self.b_in,
'b_out': self.b_out
})
self.paramMap = map_merge(self.initParamMap, self.derivedParamMap,
{'filter_type': self.filter_type})
if do_print is True:
print self.header_str
print params_to_str(self.paramMap, to_exclude=['summary_str'])
print
print self.summary_str
return True
def __init__(self, paramMap, scale_a_by_density=False, force=False):
self.header_str = """
=================================================================
GRID DETAILED RATE SIMULATION
================================================================="""
self.force_gen_inputs = False
self.force_gen_corr = False
self.force = force
# general parameters
self.dt = None
self.sim_time = None
self.eta = None
self.seed = None
self.num_snaps = None
# input parameters
self.n = None
self.input_mean = None
self.sigma = None
self.inputs_type = None
self.periodic_inputs = None
self.num_gau_mix = None
self.centers_std = None
self.inputs_seed = None
self.tap_inputs = None
self.norm_bound_add = None
self.norm_bound_mul = None
# walk parameters
self.L = None
self.nx = None
self.periodic_walk = None
self.speed = None
self.bounce = None
self.theta_sigma = None
self.position_dt = None
self.walk_time = None
self.walk_seed = None
self.variable_speed = None
self.correct_border_effects = None
# filter parameters
self.filter_type = FilterType.FILTER_INPUT
if 'filter_type' not in paramMap.keys(
) or paramMap['filter_type'] == FilterType.FILTER_INPUT:
self.tau1 = None
self.tau2 = None
self.tau3 = None
self.mu1 = None
self.mu2 = None
self.mu3 = None
else:
self.tau_in = None
self.tau_out = None
self.mu_out = None
# plasticiy params
self.a = None
self.J_av_target = None
self.gamma = None
self.up_bound = None
self.J0_std = None
self.r0 = None
self.J0_dist = None
self.J0_mean_factor = None
self.base_n = None # base number of neurons to scale a accordingly
# flags
self.add_boundary_input = None
self.clip_weights = None
self.clip_out_rate = None
self.compute_scores = None
self.scale_a_by_n = None
# set parameter values from input map
for param, value in paramMap.items():
setattr(self, param, value)
if self.scale_a_by_n is True:
self.a = self.a * self.n**2 / self.base_n**2
# parameters we never change
self.plastic = True
self.transient_time = 2.
self.arena_shape = 'square'
self.virtual_bound_ratio = 1.0
self.bounce_theta_sigma = 0.0
self.debug_vars = False
self.sigmoid_out_rate = False
self.r_out_max = 5.
self.position_dt = self.L / self.nx
if self.periodic_inputs is True:
assert (self.add_boundary_input == False)
if (self.mu1 + self.mu2 + self.mu3) < 0.:
assert (self.gamma == 0.0)
else:
assert (self.gamma > 0.0)
# init parameters map
self.initParamMap = {
'arena_shape': self.arena_shape,
'L': self.L,
'n': self.n,
'nx': self.nx,
'sigma': self.sigma,
'input_mean': self.input_mean,
'speed': self.speed,
'theta_sigma': self.theta_sigma,
'seed': self.seed,
'sim_time': self.sim_time,
'dt': self.dt,
'position_dt': self.position_dt,
'num_snaps': self.num_snaps,
'eta': self.eta,
'a': self.a,
'gamma': self.gamma,
'J_av_target': self.J_av_target,
'J0_std': self.J0_std,
'up_bound': self.up_bound,
'r0': self.r0,
'J0_mean_factor': self.J0_mean_factor,
'clip_weights': self.clip_weights,
'periodic_inputs': self.periodic_inputs,
'outside_ratio': self.outside_ratio,
'clip_out_rate': self.clip_out_rate,
'inputs_type': self.inputs_type,
'num_gau_mix': self.num_gau_mix,
'inputs_seed': self.inputs_seed,
'walk_seed': self.walk_seed,
'walk_time': self.walk_time,
'periodic_walk': self.periodic_walk,
'bounce': self.bounce,
'bounce_theta_sigma': self.bounce_theta_sigma,
'virtual_bound_ratio': self.virtual_bound_ratio,
'compute_scores': self.compute_scores,
'add_boundary_input': self.add_boundary_input,
'J0_dist': self.J0_dist,
'sigmoid_out_rate': self.sigmoid_out_rate,
'r_out_max': self.r_out_max,
'centers_std': self.centers_std
}
if self.filter_type == FilterType.FILTER_INPUT:
self.initParamMap = map_merge(
self.initParamMap, {
'tau1': self.tau1,
'tau2': self.tau2,
'tau3': self.tau3,
'mu1': self.mu1,
'mu2': self.mu2,
'mu3': self.mu3
})
else:
self.initParamMap = map_merge(
self.initParamMap, {
'tau_in': self.tau_in,
'tau_out': self.tau_out,
'mu_out': self.mu_out
})
if self.variable_speed is True:
self.initParamMap = map_merge(
self.initParamMap, {
'variable_speed': self.variable_speed,
'speed_theta': self.speed_theta,
'speed_sigma': self.speed_sigma
})
if self.correct_border_effects is True:
self.initParamMap = map_merge(
self.initParamMap, {
'correct_border_effects': self.correct_border_effects,
'border_edge_type': self.border_edge_type,
'border_size_perc': self.border_size_perc
})
if self.tap_inputs is True:
self.initParamMap = map_merge(
self.initParamMap, {
'tap_inputs': self.tap_inputs,
'tap_border_type': self.tap_border_type,
'tap_border_size': self.tap_border_size
})
if self.norm_bound_add is True:
self.initParamMap = map_merge(
self.initParamMap, {'norm_bound_add': self.norm_bound_add})
if self.norm_bound_mul is True:
self.initParamMap = map_merge(
self.initParamMap, {'norm_bound_mul': self.norm_bound_mul})
# human-readable parameter strings (just for printing)
key_params=GridRate.key_params_filter_input if self.filter_type == FilterType.FILTER_INPUT \
else GridRate.key_params_filter_output
self.key_params_str = params_to_str(self.initParamMap,
keyParams=key_params,
compact=True)
self.input_params_str = params_to_str(
self.initParamMap,
keyParams=GridInputs.get_key_params(self.initParamMap),
compact=True)
self.walk_params_str = params_to_str(
self.initParamMap,
keyParams=GridWalk.get_key_params(paramMap),
compact=True)
# generate id and paths
self.str_id = gen_string_id(self.initParamMap)
self.hash_id = gen_hash_id(self.str_id)
self.paramsPath = os.path.join(GridRate.results_path,
self.hash_id + '_log.txt')
self.dataPath = os.path.join(GridRate.results_path,
self.hash_id + '_data.npz')
self.figurePath = os.path.join(GridRate.results_path,
self.hash_id + '_fig.png')
if os.path.exists(self.dataPath):
print 'Data hash %s already present' % self.hash_id
self.do_run = False
else:
self.do_run = True
}
toSaveMap = dict(toSaveMap.items() + debugVars.items())
if self.correct_border_effects is True:
toSaveMap = dict(toSaveMap.items() +
{'border_envelope': self.border_envelope}.items())
# save
ensureParentDir(self.dataPath)
np.savez(self.dataPath, **toSaveMap)
if do_print:
print 'Result saved in: %s\n' % self.dataPath
if __name__ == '__main__':
par_map = map_merge(GridRateParams.gau_grid_small_arena_biphasic_neg, {
'r0': 10.,
'clip_out_rate': True,
'periodic_walk': False
})
sim = GridRate(par_map)
sim.post_init()
if sim.do_run and not run_from_ipython():
sim.run()
sim.post_run()
elif run_from_ipython():
sim.plot_eigs()
input_means=np.array([ 0.21 , 0.085, 0.30 , 0.10 ])
seeds=[0,1,0,0]
final_weight_maps=[]
# create pool
host=socket.gethostname()
num_procs=procs_by_host[host]
pool=Pool(processes=num_procs)
sims=[]
hashes=[]
paramMaps=[]
rate_avg_params=map_merge(
GridRateParams.gau_grid_large_arena_biphasic_neg,
{
'dt':50.,
'compute_scores':False,
})
for sigma,tau2,input_mean,seed in zip(sigmas,tau2s,input_means,seeds):
paramMap=map_merge(rate_avg_params,
{
'sigma':sigma,
'input_mean':input_mean,
'tau2':tau2,
'seed':seed,
})
def post_init(self):
##############################################################################
###### CREATE POOL
##############################################################################
self.batch_data_folder = batch_data_folder_map[self.model_type]
ensureDir(self.batch_data_folder)
# create pool
self.host = socket.gethostname()
if self.host in procs_by_host.keys():
self.num_procs = procs_by_host[self.host]
else:
self.num_procs = 7
self.pool = Pool(processes=self.num_procs)
self.sims = []
self.hashes = []
self.all_par_values = sorted(
itertools.product(*self.batch_override_map.values()))
self.batch_override_str = ' '.join([
'%s (%s-%s)' %
(key, format_val(min(values)), format_val(max(values)))
for key, values in self.batch_override_map.items()
])
# loop over all different paramater values
for par_values in self.all_par_values:
override_param_map = {
k: v
for (k, v) in zip(self.batch_override_map.keys(), par_values)
}
parMap = map_merge(self.batch_default_map, override_param_map)
if self.model_type == ModelType.MODEL_RATE:
self.sim_class = GridRate
elif self.model_type == ModelType.MODEL_RATE_AVG:
self.sim_class = GridRateAvg
elif self.model_type == ModelType.MODEL_SPIKING:
self.sim_class = GridSpikes
sim = self.sim_class(parMap)
#print sim.hash_id+' Run: %s'%sim.do_run
if self.force:
sim.force_gen_inputs = True
sim.force_gen_corr = True
sim.do_run = True
if sim.do_run is True:
self.sims.append(sim)
self.hashes.append(sim.hash_id)
# generate batch hash
self.batch_hash = gen_hash_id('_'.join(self.hashes))
self.batch_data_path = os.path.join(self.batch_data_folder,
'%s_data.npz' % self.batch_hash)
self.batch_params_path = os.path.join(
self.batch_data_folder, '%s_params.txt' % self.batch_hash)
self.batch_summary_str=\
"\n\nBATCH HASH: %s\n\nBATCH PARAMS = %s\n\n"%\
(self.batch_hash,
self.batch_override_str
)
print self.batch_summary_str
self.toSaveMap = {
'hashes': self.hashes,
'batch_override_map': self.batch_override_map,
'batch_default_map': self.batch_default_map
}
if os.path.exists(self.batch_data_path) and not self.force:
return False
else:
print '\n\n*** BATCH DATA NOT PRESENT!! ***\n\n'
print self.batch_data_path
print '%d/%d simulations to be run' % (len(
self.sims), len(self.all_par_values))
return True
def post_run(self):
#############################################################################
##### MERGE DATA
#############################################################################
print
print 'SIMULATIONS COMPLETED'
print
print 'Merging data...'
sys.stdout.flush()
initial_weights_map = {}
final_weights_map = {}
final_weight_score_map = {}
final_weight_angle_map = {}
final_weight_spacing_map = {}
final_weight_phase_map = {}
final_weight_cx_map = {}
evo_weight_scores_map = {}
final_rates_map = {}
final_rate_score_map = {}
final_rate_angle_map = {}
final_rate_spacing_map = {}
final_rate_phase_map = {}
final_rate_cx_map = {}
evo_weight_profiles_map = {}
start_clock = time.time()
# load/compute data to show for each combination of parameter_values
idx = -1
for chash, par_values in zip(self.hashes, self.all_par_values):
idx += 1
print_progress(idx,
len(self.all_par_values),
start_clock=start_clock)
sys.stdout.flush()
dataPath = os.path.join(self.sim_class.results_path,
'%s_data.npz' % chash)
try:
data = np.load(dataPath, mmap_mode='r')
except Exception:
print 'This file is corrupted: %s' % dataPath
initial_weights_map[par_values] = data['J0']
final_weights_map[par_values] = data['final_weights']
final_weight_score_map[par_values] = data['final_weight_score']
final_weight_angle_map[par_values] = data['final_weight_angle']
final_weight_spacing_map[par_values] = data['final_weight_spacing']
final_weight_phase_map[par_values] = data['final_weight_phase']
final_weight_cx_map[par_values] = data['final_weight_cx']
if 'scores' in data.keys():
evo_weight_scores_map[par_values] = data['scores']
final_rates_map[par_values] = data['final_rates']
final_rate_score_map[par_values] = data['final_rate_score']
final_rate_angle_map[par_values] = data['final_rate_angle']
final_rate_spacing_map[par_values] = data['final_rate_spacing']
final_rate_phase_map[par_values] = data['final_rate_phase']
final_rate_cx_map[par_values] = data['final_rate_cx']
# fourier profiles over time
import gridlib as gl
L = data['paramMap'][()]['L']
n = data['paramMap'][()]['n']
num_snaps = self.batch_default_map['num_snaps']
J_mat = data['J_vect'].reshape(n, n, num_snaps)
weights_dft, weights_freqs, weigths_allfreqs = gl.dft2d_num(
J_mat, L, n)
weights_dft_profiles = gl.dft2d_profiles(weights_dft)
evo_weight_profiles_map[par_values] = weights_dft_profiles
mergedDataMap = {
'initial_weights_map': initial_weights_map,
'final_weights_map': final_weights_map,
'final_weight_score_map': final_weight_score_map,
'final_weight_angle_map': final_weight_angle_map,
'final_weight_spacing_map': final_weight_spacing_map,
'final_weight_phase_map': final_weight_phase_map,
'final_weight_cx_map': final_weight_cx_map,
'evo_weight_scores_map': evo_weight_scores_map,
'final_rates_map': final_rates_map,
'final_rate_score_map': final_rate_score_map,
'final_rate_angle_map': final_rate_angle_map,
'final_rate_spacing_map': final_rate_spacing_map,
'final_rate_phase_map': final_rate_phase_map,
'final_rate_cx_map': final_rate_cx_map,
'evo_weight_profiles_map': evo_weight_profiles_map,
'weights_freqs': weights_freqs
}
self.toSaveMap = map_merge(self.toSaveMap, mergedDataMap)
# save
ensureParentDir(self.batch_data_path)
logSim(self.batch_hash,
self.batch_override_str,
self.startTimeStr,
self.endTimeStr,
self.elapsedTime,
self.batch_default_map,
self.batch_params_path,
doPrint=False)
print
print 'BATCH HASH: %s' % self.batch_hash
np.savez(self.batch_data_path, **self.toSaveMap)
print
print 'Batch data saved in: %s\n' % self.batch_data_path
print
num_seeds = 200
a = 4.
J_av_star = 0.05
sigmas = [0.0625, 0.0625]
tau2s = [0.16, 0.35]
input_means = [0.3, 0.1]
batches = []
for sigma, tau2, input_mean in zip(sigmas, tau2s, input_means):
param_map = map_merge(
GridRateParams.gau_grid_large_arena_biphasic_neg, {
'dt': 50.,
'r0': 10.,
'compute_scores': False,
'sigma': sigma,
'tau2': tau2,
'input_mean': input_mean,
'a': a
})
print 'sigma: %.4f tau2: %.3f r_av=%.3f ' % (sigma, tau2, input_mean)
batch = GridBatch(ModelType.MODEL_RATE_AVG, param_map,
{'seed': np.arange(num_seeds)})
do_run = batch.post_init()
batches.append(batch)
if do_run and not run_from_ipython():
batch.run()
