def gen_inputs_noisy_grids_scattered_fields(self,comp_scores=True):
"""
Generates regular grids and jitters the fields location
"""
# parameter fitted by eye to match perfect-grid field size
gau_sigma=self.grid_T/3.7
seed(self.inputs_seed)
# consider larger field for peaks in field but with center outside
margin=self.grid_T
XX,YY=np.mgrid[-self.L/2-margin:self.L/2+margin:self.dx,-self.L/2-margin:self.L/2+margin:self.dx]
# generate perfect grids
larger_pos=np.array([np.ravel(XX), np.ravel(YY)]).T
# generate perfect grids
seed(self.inputs_seed)
self.phases,reg_grids,self.angle_vect,self.grid_T_vect=\
gen_perfect_grids(larger_pos,self.n,self.grid_T,self.grid_angle,
self.angle_sigma,jitter_axes_angle=self.jitter_axes_angle,
grid_T_sigma=self.grid_T_sigma,jitter_axes_T=self.jitter_axes_T)
inputs_large=np.zeros_like(reg_grids)
nx_large=int(np.sqrt(reg_grids.shape[0]))
g_fun = lambda p: np.exp(-np.sum(p**2,2)/(2*gau_sigma**2))
# add a gaussian for each noisy peak center
for grid_idx in xrange(self.N):
grid=reg_grids[:,grid_idx].reshape(nx_large,nx_large)
noisy_peaks=get_noisy_peaks(grid,XX,YY,self.scatter_sigma)
# gaussian input
P0=larger_pos[np.newaxis,:,:]-noisy_peaks.T[:,np.newaxis,:]
inputs_large[:,grid_idx]=g_fun(P0).astype(np.float32).sum(axis=0)
# crop out the out the outer margin, we retain an inner square of size (self.nx, self.nx)
margin_nx=np.int((nx_large-self.nx)/2.)
inputs_unfolded=inputs_large.reshape(nx_large,nx_large,self.N)
inputs=inputs_unfolded[margin_nx:margin_nx+self.nx,margin_nx:margin_nx+self.nx]
inputs=inputs.reshape(self.nx**2,self.N)
# shift down and clip (to mimic perfect grid inputs)
inputs-=0.5
inputs=inputs.clip(0,100)
inputs=inputs/inputs.mean(axis=0)*self.input_mean
self.inputs_flat=np.ascontiguousarray(inputs, dtype=np.float32)
# compute scores
if comp_scores:
self.in_scores,self.in_spacings,self.in_angles,self.in_phases=compute_scores_evo(
self.inputs_flat,self.nx,self.L,num_steps=50)
def gen_inputs_noisy_grids(self,comp_scores=True):
"""
Generates regular grids and adds correlated Gaussian noise on top
"""
# generate perfect grids
seed(self.inputs_seed)
self.phases,grids,angle_vect,grid_T_vect=gen_perfect_grids(self.pos,self.n,self.grid_T,self.grid_angle)
self.inputs_flat,grids_flat,noise_flat=add_noise_and_normalize(self.pos,self.nx,self.N,self.noise_sigma,
self.input_mean,self.signal_weight,grids)
# compute scores
if comp_scores:
self.in_scores,self.in_spacings,self.in_angles,self.in_phases=compute_scores_evo(
self.inputs_flat,self.nx,self.L,num_steps=50)
def gen_inputs_noisy_grids_two_angles(self,comp_scores=True):
"""
Generates regular grids and adds correlated Gaussian noise on top
"""
# generate perfect grids
seed(self.inputs_seed)
phases1,grids1,angle_vect1,grid_T_vect1=gen_perfect_grids(self.pos,self.n1,self.grid_T,self.grid_angle1)
phases2,grids2,angle_vect2,grid_T_vect2=gen_perfect_grids(self.pos,self.n2,self.grid_T,self.grid_angle2)
self.phases=np.vstack([phases1,phases2])
grids=np.hstack([grids1,grids2])
self.inputs_flat,grids_flat,noise_flat=add_noise_and_normalize(self.pos,self.nx,self.N,self.noise_sigma,
self.input_mean,self.signal_weight,grids)
# compute scores
if comp_scores:
self.in_scores,self.in_spacings,self.in_angles,self.in_phases=compute_scores_evo(
self.inputs_flat,self.nx,self.L,num_steps=50)
def gen_inputs_noisy_grids_jitter(self,comp_scores=True):
"""
Generates regular grids with nosy orientations and adds correlated Gaussian noise on top
Grid scale and orientations are jittered (Gaussian distributed)
"""
# generate perfect grids
seed(self.inputs_seed)
self.phases,grids,self.angle_vect,self.grid_T_vect=\
gen_perfect_grids(self.pos,self.n,self.grid_T,self.grid_angle,
self.angle_sigma,jitter_axes_angle=self.jitter_axes_angle,
grid_T_sigma=self.grid_T_sigma,jitter_axes_T=self.jitter_axes_T)
self.inputs_flat,self.grids_flat,self.noise_flat=add_noise_and_normalize(self.pos,self.nx,self.N,
self.noise_sigma,
self.input_mean,self.signal_weight,grids)
# compute scores
if comp_scores:
self.in_scores,self.in_spacings,self.in_angles,self.in_phases=compute_scores_evo(
self.inputs_flat,self.nx,self.L,num_steps=50)
def comp_scores(self):
self.in_scores,self.in_spacings,self.in_angles,self.in_phases=compute_scores_evo(
self.inputs_flat,self.nx,self.L,num_steps=50)
def post_run(self, do_print=True):
# logging simulation end
endTime = datetime.datetime.fromtimestamp(time.time())
endTimeStr = endTime.strftime('%Y-%m-%d %H:%M:%S')
elapsedTime = clock() - self.startClock
logSim(self.hash_id,
'',
self.startTimeStr,
endTimeStr,
elapsedTime,
self.paramMap,
self.paramsPath,
doPrint=False)
if do_print:
print 'Simulation ends: %s' % endTimeStr
print 'Elapsed time: %s\n' % format_elapsed_time(elapsedTime)
# estimated output rates (boundary input excluded)
r_vect = np.dot(self.inputs_flat, self.J_vect)
self.filt_r_vect = filter_r_vect(
r_vect,
self.paramMap) + self.r0 - self.gamma * self.J_vect.sum(axis=0)
# real final output rate and score
#self.final_space_visits[self.final_space_visits==0]=-1
#self.final_space_r_out_mean=(self.final_space_r_out/self.final_space_visits).reshape(self.nx,self.nx)
# compute final weight and rate scores
self.final_weights = self.J_vect[:, -1].reshape(self.n, self.n)
score, spacing, angle, phase, cx = get_grid_params(self.final_weights,
self.L,
self.n,
num_steps=50,
return_cx=True)
self.final_weight_score = score
self.final_weight_angle = angle
self.final_weight_spacing = spacing
self.final_weight_phase = phase
self.final_weight_cx = cx
self.final_rates = self.filt_r_vect[:, -1].reshape(self.nx, self.nx)
score, spacing, angle, phase, cx = get_grid_params(self.final_rates,
self.L,
self.nx,
num_steps=50,
return_cx=True)
self.final_rate_score = score
self.final_rate_angle = angle
self.final_rate_spacing = spacing
self.final_rate_phase = phase
self.final_rate_cx = cx
# save variables
toSaveMap = {
'paramMap': self.paramMap,
'J_vect': self.J_vect,
'dJ_vect': self.dJ_vect,
'r_out_vect': self.r_out_vect,
'J0': self.J0,
'filt_r_vect': self.filt_r_vect,
#'tot_input_vect':self.tot_input_vect,
'final_weights': self.final_weights,
'final_weight_score': self.final_weight_score,
'final_weight_angle': self.final_weight_angle,
'final_weight_spacing': self.final_weight_spacing,
'final_weight_phase': self.final_weight_phase,
'final_weight_cx': self.final_weight_cx,
'final_rates': self.final_rates,
'final_rate_score': self.final_rate_score,
'final_rate_angle': self.final_rate_angle,
'final_rate_spacing': self.final_rate_spacing,
'final_rate_phase': self.final_rate_phase,
'final_rate_cx': self.final_rate_cx
}
# 'final_space_r_out':self.final_space_r_out,
# 'final_space_visits':self.final_space_visits,
# 'final_space_r_out_mean':self.final_space_r_out_mean}
# compute scores
if self.compute_scores is True:
if self.inputs_type == InputType.INPUT_GAU_GRID:
print 'Computing weight scores'
# weight scores
scores, spacings, angles, phases = compute_scores_evo(
self.J_vect, self.n, self.L)
scoresVars = {
'scores': scores,
'spacings': spacings,
'angles': angles,
'phases': phases
}
toSaveMap = dict(toSaveMap.items() + scoresVars.items())
print 'Computing rate scores'
# rate scores
rate_scores, rate_spacings, rate_angles, rate_phases = compute_scores_evo(
self.filt_r_vect, self.nx, self.L, num_steps=20)
scoresVars = {
'rate_scores': rate_scores,
'rate_spacings': rate_spacings,
'rate_angles': rate_angles,
'rate_phases': rate_phases
}
toSaveMap = dict(toSaveMap.items() + scoresVars.items())
# add debug variables for saving
if self.debug_vars is True:
#debugVars={'h_act_vect':self.h_act_vect,'h_inact_vect':self.h_inact_vect,'gg_vect':self.gg_vect}
debugVars = {
'r1_vect': self.r1_vect,
'r2_vect': self.r2_vect,
'r3_vect': self.r3_vect,
'gg_vect': self.gg_vect
}
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