def plot_stimulus(plot, rng, coh=+12.8): plot.axis_off('bottom') x = np.linspace(dt, tmax, int(tmax / dt)) y_high = np.zeros_like(x) y_low = np.zeros_like(x) for i in xrange(len(x)): if stimulus[0] < x[i] <= stimulus[1]: y_high[i] = (1 + coh / 100) / 2 + rng.normal(scale=0.1) y_low[i] = (1 - coh / 100) / 2 + rng.normal(scale=0.1) y_high += offset plot.plot(x[::n_display], y_high[::n_display], color=Figure.colors('blue'), lw=1.5, zorder=10) plot.plot(x[::n_display], y_low[::n_display], color=Figure.colors('red'), lw=1.5, zorder=9) plot.xlim(0, tmax) plot.ylim(0, 1) plot.yticks([0, 1])
def plot_stimulus(plot, rng, coh=+12.8): plot.axis_off('bottom') x = np.linspace(dt, tmax, int(tmax/dt)) y_high = np.zeros_like(x) y_low = np.zeros_like(x) for i in xrange(len(x)): if stimulus[0] < x[i] <= stimulus[1]: y_high[i] = (1 + coh/100)/2 + rng.normal(scale=0.1) y_low[i] = (1 - coh/100)/2 + rng.normal(scale=0.1) y_high += offset plot.plot(x[::n_display], y_high[::n_display], color=Figure.colors('blue'), lw=1.5, zorder=10) plot.plot(x[::n_display], y_low[::n_display], color=Figure.colors('red'), lw=1.5, zorder=9) plot.xlim(0, tmax) plot.ylim(0, 1) plot.yticks([0, 1])
def plot_inputs(trial, mod, all): # Visual input r = trial['u'][m.VISUAL_P][w] plots[mod+'_v'].plot(t, r, color=multisensory.colors['v'], lw=0.8, zorder=5) all.append(r) # Auditory input r = trial['u'][m.AUDITORY_P][w] plots[mod+'_a'].plot(t, r, color=multisensory.colors['a'], lw=0.8, zorder=5) all.append(r) # Boundaries if 'v' in mod: plots[mod+'_v'].plot(t, boundary_v*np.ones_like(t), color=Figure.colors('darkblue'), lw=0.75, zorder=10) if 'a' in mod: plots[mod+'_a'].plot(t, boundary_a*np.ones_like(t), color=Figure.colors('darkgreen'), lw=0.75, zorder=10) T = trial['t'] W, = np.where((500 < T) & (T <= 1500)) print(np.std(trial['u'][m.VISUAL_P][W])) print(np.std(trial['u'][m.AUDITORY_P][W]))
def plot_inputs(trial, mod, all): # Visual input r = trial['u'][m.VISUAL_P][w] plots[mod + '_v'].plot(t, r, color=multisensory.colors['v'], lw=0.8, zorder=5) all.append(r) # Auditory input r = trial['u'][m.AUDITORY_P][w] plots[mod + '_a'].plot(t, r, color=multisensory.colors['a'], lw=0.8, zorder=5) all.append(r) # Boundaries if 'v' in mod: plots[mod + '_v'].plot(t, boundary_v * np.ones_like(t), color=Figure.colors('darkblue'), lw=0.75, zorder=10) if 'a' in mod: plots[mod + '_a'].plot(t, boundary_a * np.ones_like(t), color=Figure.colors('darkgreen'), lw=0.75, zorder=10) T = trial['t'] W, = np.where((500 < T) & (T <= 1500)) print(np.std(trial['u'][m.VISUAL_P][W])) print(np.std(trial['u'][m.AUDITORY_P][W]))
mode=mode, n_validation=n_validation, min_error=min_error) model.train('savefile.pkl', seed=100, recover=False) #------------------------------------------------------------------------------------- # Plot #------------------------------------------------------------------------------------- from pycog import RNN from pycog.figtools import Figure rnn = RNN('savefile.pkl', {'dt': 0.5, 'var_rec': 0.01**2}) info = rnn.run(T=2 * period) fig = Figure() plot = fig.add() plot.plot(rnn.t / tau, rnn.z[0], color=Figure.colors('blue')) plot.xlim(rnn.t[0] / tau, rnn.t[-1] / tau) plot.ylim(0, 2) print rnn.t[0] print rnn.t[-1] plot.plot((rnn.t / tau)[:], (0.9 * np.power(rnn.t / (2 * period), 2))[:], color=Figure.colors('orange')) plot.xlabel(r'$t/\tau$') plot.ylabel('$\sin t$') fig.save(path='.', name='xSquared')
return join(p['trialspath'], p['name'] + '_sorted.pkl') # Simple choice function def get_choice(trial): return np.argmax(trial['z'][:, -1]) # Define "active" units def is_active(r): return np.std(r) > 0.05 # Colors colors = { 'v': Figure.colors('blue'), 'a': Figure.colors('green'), 'va': Figure.colors('orange') } #========================================================================================= def run_trials(p, args): """ Run trials. """ # Model m = p['model']
min_error = 0.1 n_validation = 100 if __name__ == '__main__': from pycog import RNN from pycog.figtools import Figure rnn = RNN('work/data/multi_sequence4mod/multi_sequence4mod.pkl', {'dt': 0.5, 'var_rec': 0.01**2, 'var_in': np.array([0.003**2])}) trial_args = {} info = rnn.run(inputs=(generate_trial, trial_args), seed=72) fig = Figure() plot = fig.add() colors = ['red', 'green', 'yellow', 'orange', 'purple', 'cyan', 'magenta', 'pink'] plot.plot(rnn.t/tau, rnn.u[0], color=Figure.colors('blue'), label='$input$') for i in range(Nout): if i % NoutSplit == 0: k = {'label': '$output%d$'%int(i / NoutSplit)} else: k = {} plot.plot(rnn.t/tau, rnn.z[i], color=Figure.colors(colors[int(i / NoutSplit)]), **k) Nexc = int(N * 0.8) np.savetxt("rnnt.txt", rnn.t/tau) np.savetxt("r4.txt", np.divide(rnn.r[:Nexc].mean(axis=0), rnn.r[Nexc:].mean(axis=0)))
train_brec=train_brec, train_bout=train_bout, var_rec=var_rec, generate_trial=generate_trial, mode=mode, n_validation=n_validation, min_error=min_error) model.train('savefile.pkl', seed=100, recover=False) #------------------------------------------------------------------------------------- # Plot #------------------------------------------------------------------------------------- from pycog import RNN from pycog.figtools import Figure rnn = RNN('savefile.pkl', {'dt': 0.5, 'var_rec': 0.01**2}) info = rnn.run(T=20 * period) fig = Figure() plot = fig.add() plot.plot(rnn.t / tau, rnn.z[0], color=Figure.colors('blue')) plot.xlim(rnn.t[0] / tau, rnn.t[-1] / tau) plot.ylim(-1, 1) plot.xlabel(r'$t/\tau$') plot.ylabel('$\sin t$') fig.save(path='.', name='sinewave')
def do(action, args, p): print("ACTION*: " + str(action)) print("ARGS*: " + str(args)) #------------------------------------------------------------------------------------- # Trials #------------------------------------------------------------------------------------- if action == 'trials': run_trials(p, args) #------------------------------------------------------------------------------------- # Psychometric function #------------------------------------------------------------------------------------- elif action == 'psychometric': #--------------------------------------------------------------------------------- # Figure setup #--------------------------------------------------------------------------------- w = 6.5 h = 3 fig = Figure(w=w, h=h, axislabelsize=7.5, labelpadx=6, labelpady=7.5, thickness=0.6, ticksize=3, ticklabelsize=6.5, ticklabelpad=2) w = 0.39 h = 0.7 L = 0.09 R = L + w + 0.1 y = 0.2 plots = {'m': fig.add([L, y, w, h]), 'c': fig.add([R, y, w, h])} #--------------------------------------------------------------------------------- # Labels #--------------------------------------------------------------------------------- plot = plots['m'] plot.xlabel('Motion coherence (\%)') plot.ylabel('Choice to right (\%)') plot = plots['c'] plot.xlabel('Color coherence (\%)') plot.ylabel('Choice to green (\%)') #--------------------------------------------------------------------------------- # Plot #--------------------------------------------------------------------------------- trialsfile = get_trialsfile(p) psychometric_function(trialsfile, plots) # Legend prop = { 'prop': { 'size': 7 }, 'handlelength': 1.2, 'handletextpad': 1.1, 'labelspacing': 0.5 } plots['m'].legend(bbox_to_anchor=(0.41, 1), **prop) #--------------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name'] + '_' + action) fig.close() #------------------------------------------------------------------------------------- # Sort #------------------------------------------------------------------------------------- elif action == 'sort': trialsfile = get_trialsfile(p) sortedfile = get_sortedfile(p) sort_trials(trialsfile, sortedfile) #------------------------------------------------------------------------------------- # Plot single-unit activity #------------------------------------------------------------------------------------- elif action == 'units': from glob import glob # Remove existing files print("[ {}.do ]".format(THIS)) filenames = glob('{}_unit*'.format(join(p['figspath'], p['name']))) for filename in filenames: os.remove(filename) print(" Removed {}".format(filename)) trialsfile = get_trialsfile(p) sortedfile = get_sortedfile(p) units = get_active_units(trialsfile) for unit in units: #----------------------------------------------------------------------------- # Figure setup #----------------------------------------------------------------------------- w = 2.5 h = 6 fig = Figure(w=w, h=h, axislabelsize=7.5, labelpadx=6, labelpady=7.5, thickness=0.6, ticksize=3, ticklabelsize=6.5, ticklabelpad=2) w = 0.55 x0 = 0.3 h = 0.17 dy = h + 0.06 y0 = 0.77 y1 = y0 - dy y2 = y1 - dy y3 = y2 - dy plots = { 'choice': fig.add([x0, y0, w, h]), 'motion_choice': fig.add([x0, y1, w, h]), 'colour_choice': fig.add([x0, y2, w, h]), 'context_choice': fig.add([x0, y3, w, h]) } #----------------------------------------------------------------------------- # Plot #----------------------------------------------------------------------------- plot_unit(unit, sortedfile, plots, sortby_fontsize=7) plots['context_choice'].xlabel('Time (ms)') #----------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name'] + '_unit{:03d}'.format(unit)) fig.close() print("[ {}.do ] {} units processed.".format(THIS, len(units))) #------------------------------------------------------------------------------------- # Regress #------------------------------------------------------------------------------------- elif action == 'regress': trialsfile = get_trialsfile(p) sortedfile = get_sortedfile(p) betafile = get_betafile(p) regress(trialsfile, sortedfile, betafile) #------------------------------------------------------------------------------------- elif action == 'inactivation': # load Weight value info import cPickle as pickle n_ne = 120 try: w_inact_bin = int(args[1]) except: w_inact_bin = 10 try: w_inact_dep = int(args[2]) except: w_inact_dep = int(n_ne / w_inact_bin) fn = 'C:\\Users\\sasak\\OneDrive\\workspace\\pycog\\examples\\work\\data\\mante\\mante_init.pkl' with open(fn, 'rb') as f: data = pickle.load(f) Wrec_init = data['best']['params'][1] fn = 'C:\\Users\\sasak\\OneDrive\\workspace\\pycog\\examples\\work\\data\\mante\\mante.pkl' with open(fn, 'rb') as f: data = pickle.load(f) Wrec_last = data['best']['params'][1] Wrec_diff = Wrec_init - Wrec_last Wee_diff = Wrec_diff[:n_ne, :n_ne] run_trials_inact(p, None, args) # full condition # sort descending order Neu_rec_diff = np.mean(np.abs(Wee_diff), axis=1) sorted_id = np.argsort(Neu_rec_diff)[::-1] for i in xrange(w_inact_dep): id_inact = sorted_id[:(i + 1) * w_inact_bin] run_trials_inact(p, id_inact, args) # sort ascending order Neu_rec_diff = np.mean(np.abs(Wee_diff), axis=1) sorted_id = np.argsort(Neu_rec_diff) for i in xrange(w_inact_dep): id_inact = sorted_id[:(i + 1) * w_inact_bin] run_trials_inact(p, id_inact, args) # shuffled order rng = np.random.RandomState(p['seed']) #rng = np.random.RandomState(data['params']['seed']) sorted_id = range(n_ne) rng.shuffle(sorted_id) for i in xrange(w_inact_dep): id_inact = sorted_id[:(i + 1) * w_inact_bin] run_trials_inact(p, id_inact, args) #------------------------------------------------------------------------------------- else: print("[ {}.do ] Unrecognized action.".format(THIS))
varstim_trialsfile = join(paper.scratchpath, 'rdm_varstim', 'trials', 'rdm_varstim_trials.pkl') varstim_sortedfile = join(paper.scratchpath, 'rdm_varstim', 'trials', 'rdm_varstim_sorted_stim_onset.pkl') rt_trialsfile = join(paper.scratchpath, 'rdm_rt', 'trials', 'rdm_rt_trials.pkl') rt_sortedfile = join(paper.scratchpath, 'rdm_rt', 'trials', 'rdm_rt_sorted_response.pkl') varstim_unit = 10 rt_unit = 68 #========================================================================================= # Figure setup #========================================================================================= fig = Figure(w=4.3, h=6.6, axislabelsize=7, labelpadx=5, labelpady=5, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) w = 0.35 dx = 0.49 x0 = 0.12 x1 = x0 + dx h = 0.17 dy = 0.215 y0 = 0.775 y1 = y0 - dy y2 = y1 - dy - 0.03 y3 = y2 - dy - 0.03 w_inset = 0.12 h_inset = 0.07
def psychometric_function(trialsfile, plots=None, **kwargs): """ Psychometric function. """ # Load trials trials, ntrials = load_trials(trialsfile) #------------------------------------------------------------------------------------- # Compute psychometric function #------------------------------------------------------------------------------------- results = {cond: {} for cond in ['mm', 'mc', 'cm', 'cc']} ncorrect = 0 for trial in trials: info = trial['info'] coh_m = info['left_right_m']*info['coh_m'] coh_c = info['left_right_c']*info['coh_c'] choice = get_choice(trial) if choice == info['choice']: ncorrect += 1 if info['context'] == 'm': results['mm'].setdefault(coh_m, []).append(choice) results['mc'].setdefault(coh_c, []).append(choice) else: results['cm'].setdefault(coh_m, []).append(choice) results['cc'].setdefault(coh_c, []).append(choice) print("[ {}.psychometric_function ] {:.2f}% correct." .format(THIS, 100*ncorrect/ntrials)) for cond in results: choice_by_coh = results[cond] cohs = np.sort(np.array(choice_by_coh.keys())) p0 = np.zeros(len(cohs)) for i, coh in enumerate(cohs): choices = np.array(choice_by_coh[coh]) p0[i] = 1 - np.sum(choices)/len(choices) scaled_cohs = SCALE*cohs results[cond] = (scaled_cohs, p0) #------------------------------------------------------------------------------------- # Plot #------------------------------------------------------------------------------------- if plots is not None: ms = kwargs.get('ms', 5) color_m = '0.2' color_c = Figure.colors('darkblue') for cond, result in results.items(): # Context if cond[0] == 'm': color = color_m label = 'Motion context' else: color = color_c label = 'Color context' # Stimulus if cond[1] == 'm': plot = plots['m'] else: plot = plots['c'] # Result scaled_cohs, p0 = result # Data points plot.plot(scaled_cohs, 100*p0, 'o', ms=ms, mew=0, mfc=color, zorder=10) # Fit try: popt, func = fittools.fit_psychometric(scaled_cohs, p0) fit_cohs = np.linspace(min(scaled_cohs), max(scaled_cohs), 201) fit_p0 = func(fit_cohs, **popt) plot.plot(fit_cohs, 100*fit_p0, color=color, lw=1, zorder=5, label=label) except RuntimeError: print("[ {}.psychometric_function ]".format(THIS) + " Unable to fit, drawing a line through the points.") plot.plot(scaled_cohs, 100*p0, color=color, lw=1, zorder=5, label=label) plot.lim('x', scaled_cohs) plot.ylim(0, 100) #------------------------------------------------------------------------------------- return results
def do(action, args, p): """ Manage tasks. """ print("ACTION*: " + str(action)) print("ARGS*: " + str(args)) #------------------------------------------------------------------------------------- # Trials #------------------------------------------------------------------------------------- if action == 'trials': run_trials(p, args) #------------------------------------------------------------------------------------- # Psychometric function #------------------------------------------------------------------------------------- elif action == 'psychometric': fig = Figure() plot = fig.add() #--------------------------------------------------------------------------------- # Plot #--------------------------------------------------------------------------------- trialsfile = get_trialsfile(p) psychometric_function(trialsfile, plot) plot.xlabel(r'Rate (events/sec)') plot.ylabel(r'Percent high') #--------------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name']+'_'+action) fig.close() #------------------------------------------------------------------------------------- # Sort #------------------------------------------------------------------------------------- elif action == 'sort': trialsfile = get_trialsfile(p) sortedfile = get_sortedfile(p) sort_trials(trialsfile, sortedfile) #------------------------------------------------------------------------------------- # Plot single-unit activity #------------------------------------------------------------------------------------- elif action == 'units': from glob import glob # Remove existing files print("[ {}.do ]".format(THIS)) filenames = glob('{}_unit*'.format(join(p['figspath'], p['name']))) for filename in filenames: os.remove(filename) print(" Removed {}".format(filename)) # Load sorted trials sortedfile = get_sortedfile(p) with open(sortedfile) as f: t, sorted_trials = pickle.load(f) for i in xrange(p['model'].N): # Check if the unit does anything active = False for r in sorted_trials.values(): if is_active(r[i]): active = True break if not active: continue fig = Figure() plot = fig.add() #--------------------------------------------------------------------------------- # Plot #--------------------------------------------------------------------------------- plot_unit(i, sortedfile, plot) plot.xlabel('Time (ms)') plot.ylabel('Firing rate (a.u.)') #--------------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name']+'_unit{:03d}'.format(i)) fig.close() #------------------------------------------------------------------------------------- else: print("[ {}.do ] Unrecognized action.".format(THIS))
if __name__ == '__main__': from pycog import Model model = Model(N=N, Nout=Nout, ei=ei, tau=tau, dt=dt, train_brec=train_brec, train_bout=train_bout, var_rec=var_rec, generate_trial=generate_trial, mode=mode, n_validation=n_validation, min_error=min_error) model.train('savefile.pkl', seed=100, recover=False) #------------------------------------------------------------------------------------- # Plot #------------------------------------------------------------------------------------- from pycog import RNN from pycog.figtools import Figure rnn = RNN('savefile.pkl', {'dt': 0.5, 'var_rec': 0.01**2}) info = rnn.run(T=20*period) fig = Figure() plot = fig.add() plot.plot(rnn.t/tau, rnn.z[0], color=Figure.colors('blue')) plot.xlim(rnn.t[0]/tau, rnn.t[-1]/tau) plot.ylim(-1, 1) plot.xlabel(r'$t/\tau$') plot.ylabel('$\sin t$') fig.save(path='.', name='sinewave')
savefile = join(datapath, 'mante_areas', 'mante_areas.pkl') rnn2 = RNN(savefile, verbose=True) # Load model modelfile = join(base, 'examples', 'models', 'mante_areas.py') m = imp.load_source('model', modelfile) #========================================================================================= # Figure setup #========================================================================================= w = 7.5 h = 3.8 r = w/h fig = Figure(w=w, h=h, axislabelsize=7, labelpadx=6, labelpady=6, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) w_rec = 0.38 h_rec = r*w_rec w_in = 0.04 h_in = h_rec w_out = w_rec h_out = r*w_in hspace = 0.022 vspace = r*hspace dx = 0.04 x0 = 0.035
('rdm_fixed', '3C: Decision-making (Dale, fixed)'), ('mante', '4: Context-dependent int.'), ('mante_areas', '5B: Context-dependent int. (areas)'), ('multisensory', '6: Multisensory int.'), ('romo', '7: Parametric working memory'), ('lee', '8: Lee')] labels = list('ABCDEFGHIJ') #========================================================================================= # Figure setup #========================================================================================= fig = Figure(w=3.8, h=6.75, axislabelsize=6.5, labelpadx=4, labelpady=3, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) ncols = 2 nrows = 5 w = 0.36 dx = w + 0.12 x0 = 0.12 xall = x0 + dx * np.arange(ncols) h = 0.13 y0 = 0.82
savefile = join(base, 'examples', 'work', 'data', 'lee', 'lee.pkl') trialsfile = join(paper.scratchpath, 'lee', 'trials', 'lee_trials.pkl') # Model modelfile = join(base, 'examples', 'models', 'lee.py') m = imp.load_source('model', modelfile) #========================================================================================= # Figure setup #========================================================================================= w = 7.5 h = 6.5 r = w/h fig = Figure(w=w, h=h, axislabelsize=7, labelpadx=5, labelpady=6, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) w = 0.095 dx = w + 0.02 x0 = 0.07 xall = [x0+i*dx for i in xrange(m.nseq)] h = 0.1 dy = 0.05 y0 = 0.55 y1 = y0 - h - dy - 0.05 y2 = y1 - h - dy y3 = y2 - h - dy y_task = 0.85
} # Color map cmap = mpl.cm.jet norm = mpl.colors.Normalize(vmin=m.fmin, vmax=m.fmax) smap = mpl.cm.ScalarMappable(norm, cmap) #To plot frequencies as different colors #========================================================================================= # Figure setup #========================================================================================= w = 6.3 #width, height, and the ratio h = 4 r = w/h fig = Figure(w=w, h=h, axislabelsize=7, labelpadx=5, labelpady=5.5, #initiate figure thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) #----------------------------------------------------------------------------------------- # Inputs #----------------------------------------------------------------------------------------- w = 0.25 dx = w + 0.04 x0 = 0.09 h = 0.165 dy = h + 0.045 y0 = 0.78 y1 = y0 - dy
def do(action, args, p): """ Manage tasks. """ print("ACTION*: " + str(action)) print("ARGS*: " + str(args)) #------------------------------------------------------------------------------------- # Trials #------------------------------------------------------------------------------------- if action == 'trials': run_trials(p, args) #------------------------------------------------------------------------------------- # Sort #------------------------------------------------------------------------------------- elif action == 'sort_stim_onset': sort_trials(get_trialsfile(p), get_sortedfile_stim_onset(p)) #------------------------------------------------------------------------------------- # activate state #------------------------------------------------------------------------------------- # TODO plot multiple units in the same figure # TODO replace units name with real neurons elif action == 'activatestate': # Model m = p['model'] # Intensity try: intensity = float(args[0]) except: intensity = 1 # Plot unit try: unit = int(args[1]) if unit == -1: unit = None except: unit = None # Create RNN if 'init' in args: print("* Initial network.") base, ext = os.path.splitext(p['savefile']) savefile_init = base + '_init' + ext rnn = RNN(savefile_init, {'dt': p['dt']}, verbose=True) else: rnn = RNN(p['savefile'], {'dt': p['dt']}, verbose=True) trial_func = p['model'].generate_trial trial_args = { 'name': 'test', 'catch': False, 'intensity': intensity, } info = rnn.run(inputs=(trial_func, trial_args), seed=p['seed']) # Summary mean = np.mean(rnn.z) std = np.std(rnn.z) print("Intensity: {:.6f}".format(intensity)) print("Mean output: {:.6f}".format(mean)) print("Std. output: {:.6f}".format(std)) # Figure setup x = 0.12 y = 0.12 w = 0.80 h = 0.80 dashes = [3.5, 1.5] t_forward = 1e-3 * np.array(info['epochs']['forward']) t_stimulus = 1e-3 * np.array(info['epochs']['stimulus']) t_reversal = 1e-3 * np.array(info['epochs']['reversal']) fig = Figure(w=4, h=3, axislabelsize=7, labelpadx=5, labelpady=5, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2) plots = { 'in': fig.add([x, y + 0.72 * h, w, 0.3 * h]), 'out': fig.add([x, y, w, 0.65 * h]), } plot = plots['in'] plot.ylabel('Input', labelpad=7, fontsize=6.5) plot = plots['out'] plot.xlabel('Time (sec)', labelpad=6.5) plot.ylabel('Output', labelpad=7, fontsize=6.5) # ----------------------------------------------------------------------------------------- # Input # ----------------------------------------------------------------------------------------- plot = plots['in'] plot.axis_off('bottom') plot.plot(1e-3 * rnn.t, rnn.u[0], color=Figure.colors('red'), lw=0.5) plot.lim('y', rnn.u[0]) plot.xlim(1e-3 * rnn.t[0], 1e-3 * rnn.t[-1]) # ----------------------------------------------------------------------------------------- # Output # ----------------------------------------------------------------------------------------- plot = plots['out'] # Outputs colors = [Figure.colors('orange'), Figure.colors('blue')] if unit is None: plot.plot(1e-3 * rnn.t, rnn.z[0], color=colors[0], label='Forward module') plot.plot(1e-3 * rnn.t, rnn.z[1], color=colors[1], label='Reversal module') plot.lim('y', np.ravel(rnn.z), lower=0) else: plot.plot(1e-3 * rnn.t, rnn.r[unit], color=colors[1], label='unit ' + str(unit)) plot.lim('y', np.ravel(rnn.r[unit])) plot.xlim(1e-3 * rnn.t[0], 1e-3 * rnn.t[-1]) # Legend props = {'prop': {'size': 7}} plot.legend(bbox_to_anchor=(1.1, 1.6), **props) plot.vline(t_forward[-1], color='0.2', linestyle='--', lw=1, dashes=dashes) plot.vline(t_reversal[0], color='0.2', linestyle='--', lw=1, dashes=dashes) # Epochs plot.text(np.mean(t_forward), plot.get_ylim()[1], 'forward', ha='center', va='center', fontsize=7) plot.text(np.mean(t_stimulus), plot.get_ylim()[1], 'stimulus', ha='center', va='center', fontsize=7) plot.text(np.mean(t_reversal), plot.get_ylim()[1], 'reversal', ha='center', va='center', fontsize=7) if 'init' in args: savename = p['name'] + '_' + action + '_init' else: savename = p['name'] + '_' + action if unit is not None: savename += '_unit_' + str(unit) fig.save(path=p['figspath'], name=savename) fig.close() # ------------------------------------------------------------------------------------- # Plot single-unit activity aligned to stimulus onset # ------------------------------------------------------------------------------------- elif action == 'units_stim_onset': from glob import glob try: lower_bon = float(args[0]) except: lower_bon = None try: higher_bon = float(args[1]) except: higher_bon = None # Remove existing files unitpath = join(p['figspath'], 'units') filenames = glob(join(unitpath, p['name'] + '_stim_onset_unit*')) for filename in filenames: os.remove(filename) print("Removed {}".format(filename)) # Load sorted trials sortedfile = get_sortedfile_stim_onset(p) with open(sortedfile) as f: t, sorted_trials = pickle.load(f) rnn = RNN(p['savefile'], {'dt': p['dt']}, verbose=True) trial_func = p['model'].generate_trial trial_args = { 'name': 'test', 'catch': False, } info = rnn.run(inputs=(trial_func, trial_args), seed=p['seed']) t_stimulus = np.array(info['epochs']['stimulus']) stimulus_d = t_stimulus[1] - t_stimulus[0] for i in xrange(p['model'].N): # Check if the unit does anything # active = False # for r in sorted_trials.values(): # if is_active(r[i]): # active = True # break # if not active: # continue dashes = [3.5, 1.5] fig = Figure() plot = fig.add() # ----------------------------------------------------------------------------- # Plot # ----------------------------------------------------------------------------- plot_unit(i, sortedfile, plot, tmin=lower_bon, tmax=higher_bon) plot.xlabel('Time (ms)') plot.ylabel('Firing rate (a.u.)') props = { 'prop': { 'size': 8 }, 'handletextpad': 1.02, 'labelspacing': 0.6 } plot.legend(bbox_to_anchor=(0.18, 1), **props) plot.vline(0, color='0.2', linestyle='--', lw=1, dashes=dashes) plot.vline(stimulus_d, color='0.2', linestyle='--', lw=1, dashes=dashes) # Epochs plot.text(-np.mean((0, stimulus_d)), plot.get_ylim()[1], 'forward', ha='center', va='center', fontsize=7) plot.text(np.mean((0, stimulus_d)), plot.get_ylim()[1], 'stimulus', ha='center', va='center', fontsize=7) plot.text(3 * np.mean((0, stimulus_d)), plot.get_ylim()[1], 'reversal', ha='center', va='center', fontsize=7) # ----------------------------------------------------------------------------- fig.save(path=unitpath, name=p['name'] + '_stim_onset_unit{:03d}'.format(i)) fig.close() #------------------------------------------------------------------------------------- # Selectivity #------------------------------------------------------------------------------------- elif action == 'selectivity': try: lower = float(args[0]) except: lower = None try: higher = float(args[1]) except: higher = None # Model m = p['model'] trialsfile = get_trialsfile(p) dprime = get_choice_selectivity(trialsfile, lower_bon=lower, higher_bon=higher) def get_first(x, p): return x[:int(p * len(x))] psig = 0.25 units = np.arange(len(dprime)) try: idx = np.argsort(abs(dprime[m.EXC]))[::-1] exc = get_first(units[m.EXC][idx], psig) idx = np.argsort(abs(dprime[m.INH]))[::-1] inh = get_first(units[m.INH][idx], psig) idx = np.argsort(dprime[exc])[::-1] units_exc = list(exc[idx]) idx = np.argsort(dprime[inh])[::-1] units_inh = list(units[inh][idx]) units = units_exc + units_inh dprime = dprime[units] except AttributeError: idx = np.argsort(abs(dprime))[::-1] all = get_first(units[idx], psig) idx = np.argsort(dprime[all])[::-1] units = list(units[all][idx]) dprime = dprime[units] # Save d' filename = get_dprimefile(p) np.savetxt(filename, dprime) print("[ {}.do ] d\' saved to {}".format(THIS, filename)) # Save selectivity filename = get_selectivityfile(p) np.savetxt(filename, units, fmt='%d') print("[ {}.do ] Choice selectivity saved to {}".format( THIS, filename)) #------------------------------------------------------------------------------------- else: print("[ {}.do ] Unrecognized action.".format(THIS))
def plot_unit(unit, sortedfile, plots, t0=0, tmin=-np.inf, tmax=np.inf, **kwargs): # Load sorted trials with open(sortedfile) as f: t, sorted_trials = pickle.load(f) #------------------------------------------------------------------------------------- # Labels #------------------------------------------------------------------------------------- # Unit no. fontsize = kwargs.get('unit_fontsize', 7) plots['choice'].text_upper_center('Unit '+str(unit), dy=0.07, fontsize=fontsize) # Sort-by if kwargs.get('sortby_fontsize') is not None: fontsize = kwargs['sortby_fontsize'] labels = { 'choice': 'choice', 'motion_choice': 'motion \& choice', 'colour_choice': 'color \& choice', 'context_choice': 'context \& choice' } for k , label in labels.items(): plots[k].ylabel(label) #------------------------------------------------------------------------------------- # Setup #------------------------------------------------------------------------------------- # Duration to plot w, = np.where((tmin <= t) & (t <= tmax)) t = t - t0 # Linestyle def get_linestyle(choice): if choice == +1: return '-' return '--' # Line width lw = kwargs.get('lw', 1) # For setting axis limits yall = [] #------------------------------------------------------------------------------------- # Choice #------------------------------------------------------------------------------------- plot = plots['choice'] condition_averaged = sorted_trials['choice'] for (choice,), r in condition_averaged.items(): ls = get_linestyle(choice) plot.plot(t[w], r[unit,w], ls, color=Figure.colors('red'), lw=lw) yall.append(r[unit,w]) plot.xlim(t[w][0], t[w][-1]) plot.xticks([t[w][0], 0, t[w][-1]]) #------------------------------------------------------------------------------------- # Motion & choice #------------------------------------------------------------------------------------- plot = plots['motion_choice'] condition_averaged = sorted_trials['motion_choice'] abscohs = [] for (choice, coh, context) in condition_averaged: abscohs.append(abs(coh)) abscohs = sorted(list(set(abscohs))) for (choice, coh, context), r in condition_averaged.items(): if context != 'm': continue ls = get_linestyle(choice) idx = abscohs.index(abs(coh)) basecolor = 'k' if idx == 0: color = apply_alpha(basecolor, 0.4) elif idx == 1: color = apply_alpha(basecolor, 0.7) else: color = apply_alpha(basecolor, 1) plot.plot(t[w], r[unit,w], ls, color=color, lw=lw) yall.append(r[unit,w]) plot.xlim(t[w][0], t[w][-1]) plot.xticks([t[w][0], 0, t[w][-1]]) #------------------------------------------------------------------------------------- # Colour & choice #------------------------------------------------------------------------------------- plot = plots['colour_choice'] condition_averaged = sorted_trials['colour_choice'] abscohs = [] for (choice, coh, context) in condition_averaged: abscohs.append(abs(coh)) abscohs = sorted(list(set(abscohs))) for (choice, coh, context), r in condition_averaged.items(): if context != 'c': continue ls = get_linestyle(choice) idx = abscohs.index(abs(coh)) basecolor = Figure.colors('darkblue') if idx == 0: color = apply_alpha(basecolor, 0.4) elif idx == 1: color = apply_alpha(basecolor, 0.7) else: color = apply_alpha(basecolor, 1) plot.plot(t[w], r[unit,w], ls, color=color, lw=lw) yall.append(r[unit,w]) plot.xlim(t[w][0], t[w][-1]) plot.xticks([t[w][0], 0, t[w][-1]]) #------------------------------------------------------------------------------------- # Context & choice #------------------------------------------------------------------------------------- plot = plots['context_choice'] condition_averaged = sorted_trials['context_choice'] for (choice, context), r in condition_averaged.items(): ls = get_linestyle(choice) if context == 'm': color = 'k' else: color = Figure.colors('darkblue') plot.plot(t[w], r[unit,w], ls, color=color, lw=lw) yall.append(r[unit,w]) plot.xlim(t[w][0], t[w][-1]) plot.xticks([t[w][0], 0, t[w][-1]]) return yall
def do(action, args, p): """ Manage tasks. """ print("ACTION*: " + str(action)) print("ARGS*: " + str(args)) #------------------------------------------------------------------------------------- # Trials #------------------------------------------------------------------------------------- if action == 'trials': run_trials(p, args) #------------------------------------------------------------------------------------- # Psychometric function #------------------------------------------------------------------------------------- elif action == 'psychometric': fig = Figure() plot = fig.add() #--------------------------------------------------------------------------------- # Plot #--------------------------------------------------------------------------------- trialsfile = get_trialsfile(p) psychometric_function(trialsfile, plot) plot.xlabel('$f_1$ (Hz)') plot.ylabel('$f_2$ (Hz)') #--------------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name']+'_'+action) fig.close() #------------------------------------------------------------------------------------- # Sort #------------------------------------------------------------------------------------- elif action == 'sort': sort_trials(get_trialsfile(p), get_sortedfile(p)) #------------------------------------------------------------------------------------- # Plot single-unit activity aligned to stimulus onset #------------------------------------------------------------------------------------- elif action == 'units': from glob import glob # Remove existing files print("[ {}.do ]".format(THIS)) filenames = glob('{}_unit*'.format(join(p['figspath'], p['name']))) for filename in filenames: os.remove(filename) print(" Removed {}".format(filename)) # Load sorted trials sortedfile = get_sortedfile(p) with open(sortedfile) as f: t, sorted_trials = pickle.load(f) # Colormap cmap = mpl.cm.jet norm = mpl.colors.Normalize(vmin=p['model'].fmin, vmax=p['model'].fmax) smap = mpl.cm.ScalarMappable(norm, cmap) for i in xrange(p['model'].N): # Check if the unit does anything active = False for condition_averaged in sorted_trials.values(): if is_active(condition_averaged[i]): active = True break if not active: continue fig = Figure() plot = fig.add() #----------------------------------------------------------------------------- # Plot #----------------------------------------------------------------------------- plot_unit(i, sortedfile, plot, smap) plot.xlabel('Time (ms)') plot.ylabel('Firing rate (a.u.)') props = {'prop': {'size': 8}, 'handletextpad': 1.02, 'labelspacing': 0.6} plot.legend(bbox_to_anchor=(0.18, 1), **props) #----------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name']+'_unit{:03d}'.format(i)) fig.close() #------------------------------------------------------------------------------------- else: print("[ {}.do ] Unrecognized action '{}'.".format(THIS, action))
def plot_statespace(trialsfile, sortedfile, betafile, plots): # Load trials trials, ntrials = load_trials(trialsfile) # Load sorted trials with open(sortedfile) as f: t, sorted_trials = pickle.load(f) # Load task axes with open(betafile) as f: M = pickle.load(f).T # Active units units = get_active_units(trialsfile) # Epoch to plot start, end = trials[0]['info']['epochs']['stimulus'] start += 0 end += 0 w, = np.where((start <= t) & (t <= end)) # Down-sample dt = t[1] - t[0] step = int(50/dt) w = w[::step] # Colors color_m = 'k' color_c = Figure.colors('darkblue') xall = [] yall = [] #------------------------------------------------------------------------------------- # Labels #------------------------------------------------------------------------------------- plots['c1'].xlabel('Choice') #------------------------------------------------------------------------------------- # Motion context: motion vs. choice, sorted by coherence #------------------------------------------------------------------------------------- plot = plots['m1'] p_vc = {} for cond, r in sorted_trials['motion_choice'].items(): if cond[2] == 'm': p_vc[cond] = M.dot(r[units,:][:,w]) x, y = plot_taskaxes(plot, MOTION, p_vc, color_m) xall.append(x) yall.append(y) plot.ylabel('Motion') #------------------------------------------------------------------------------------- # Motion context: motion vs. choice, sorted by coherence #------------------------------------------------------------------------------------- plot = plots['m2'] p_vc = {} for cond, r in sorted_trials['motion_choice'].items(): if cond[2] == 'm': p_vc[cond] = M.dot(r[units,:][:,w]) x, y = plot_taskaxes(plot, COLOUR, p_vc, color_m) xall.append(x) yall.append(y) #------------------------------------------------------------------------------------- # Motion context: colour vs. choice, sorted by colour #------------------------------------------------------------------------------------- plot = plots['m3'] p_vc = {} for cond, r in sorted_trials['colour_choice'].items(): if cond[2] == 'm': p_vc[cond] = M.dot(r[units,:][:,w]) x, y = plot_taskaxes(plot, COLOUR, p_vc, color_c) xall.append(x) yall.append(y) #------------------------------------------------------------------------------------- # Colour context: motion vs. choice, sorted by motion #------------------------------------------------------------------------------------- plot = plots['c1'] p_vc = {} for cond, r in sorted_trials['motion_choice'].items(): if cond[2] == 'c': p_vc[cond] = M.dot(r[units,:][:,w]) x, y = plot_taskaxes(plot, MOTION, p_vc, color_m) xall.append(x) yall.append(y) #------------------------------------------------------------------------------------- # Colour context: motion vs. choice, sorted by colour #------------------------------------------------------------------------------------- plot = plots['c2'] p_vc = {} for cond, r in sorted_trials['colour_choice'].items(): if cond[2] == 'c': p_vc[cond] = M.dot(r[units,:][:,w]) x, y = plot_taskaxes(plot, MOTION, p_vc, color_c) xall.append(x) yall.append(y) #------------------------------------------------------------------------------------- # Colour context: colour vs. choice, sorted by colour #------------------------------------------------------------------------------------- plot = plots['c3'] p_vc = {} for cond, r in sorted_trials['colour_choice'].items(): if cond[2] == 'c': p_vc[cond] = M.dot(r[units,:][:,w]) x, y = plot_taskaxes(plot, COLOUR, p_vc, color_c) xall.append(x) yall.append(y) #------------------------------------------------------------------------------------- # Shared axes #------------------------------------------------------------------------------------- xall = np.concatenate(xall) yall = np.concatenate(yall) for plot in plots.values(): plot.aspect(1.5) plot.lim('x', xall) plot.lim('y', yall)
def tuning_corr(trialsfile, sortedfile, plot_sig, plot_corr=None, plot_stim=None, plot_delay=None, t0=0, **kwargs): """ Plot correlation of a1 between different times. """ units, a1s, pvals = tuning(sortedfile) # Get first trial trials, _ = load_trials(trialsfile) trial = trials[0] info = trial['info'] t = trial['t'] _, delay_end = info['epochs']['delay'] delay_end = 1e-3 * (delay_end - t0) t_stim = np.mean(info['epochs']['f1']) idx_stim = np.where(t >= t_stim)[0][0] t_delay = np.mean(info['epochs']['delay']) idx_delay = np.where(t >= t_delay)[0][0] t_delay_end = info['epochs']['delay'][1] idx_delay_end = np.where(t > t_delay_end)[0][0] t_f2_end = info['epochs']['f2'][1] idx_f2_end = np.where(t > t_f2_end)[0][0] t_all = 1e-3 * (t[idx_stim:idx_delay_end] - t0) idx_all = np.arange(len(t))[idx_stim:idx_delay_end] # Plot correlation across time if plot_corr is not None: plot = plot_corr # With stimulus period corr = [] for k in idx_all: corr.append(stats.pearsonr(a1s[:, idx_stim], a1s[:, k])[0]) plot.plot(t_all, corr, color=Figure.colors('blue'), lw=kwargs.get('lw', 1)) # With stimulus period corr = [] for k in idx_all: corr.append(stats.pearsonr(a1s[:, idx_delay], a1s[:, k])[0]) plot.plot(t_all, corr, color=Figure.colors('green'), lw=kwargs.get('lw', 1)) plot.xlim(-1e-3 * t0, delay_end) plot.ylim(-1, 1) # Plot fraction of significantly tuned units. if plot_sig is not None: plot = plot_sig psig = np.sum(1 * (pvals < 0.05), axis=0) / len(units) plot.plot(1e-3 * (t[1:idx_f2_end] - t0), psig[1:idx_f2_end], color='0.2', lw=kwargs.get('lw', 1)) plot.xlim(1e-3 * (t[0] - t0), 1e-3 * (t[idx_f2_end - 1] - t0)) #plot.lim('y', psig, lower=0) plot.ylim(0, 1) # Shared plot properties prop = {'mfc': '0.2', 'mec': 'none', 'ms': kwargs.get('ms', 2)} # Plot a1, end of delay vs. stimulus if plot_stim is not None: plot = plot_stim plot.equal() for i in xrange(len(units)): plot.plot(a1s[i, idx_stim], a1s[i, idx_delay_end], 'o', **prop) # Plot a1, end of delay vs. middle of delay if plot_delay is not None: plot = plot_delay plot.equal() for i in xrange(len(units)): plot.plot(a1s[i, idx_delay], a1s[i, idx_delay_end], 'o', **prop)
def do(action, args, p): print("ACTION*: " + str(action)) print("ARGS*: " + str(args)) #------------------------------------------------------------------------------------- # Trials #------------------------------------------------------------------------------------- if action == 'trials': run_trials(p, args) #------------------------------------------------------------------------------------- # Psychometric function #------------------------------------------------------------------------------------- elif action == 'psychometric': #--------------------------------------------------------------------------------- # Figure setup #--------------------------------------------------------------------------------- w = 6.5 h = 3 fig = Figure(w=w, h=h, axislabelsize=7.5, labelpadx=6, labelpady=7.5, thickness=0.6, ticksize=3, ticklabelsize=6.5, ticklabelpad=2) w = 0.39 h = 0.7 L = 0.09 R = L + w + 0.1 y = 0.2 plots = {'m': fig.add([L, y, w, h]), 'c': fig.add([R, y, w, h])} #--------------------------------------------------------------------------------- # Labels #--------------------------------------------------------------------------------- plot = plots['m'] plot.xlabel('Motion coherence (\%)') plot.ylabel('Choice to right (\%)') plot = plots['c'] plot.xlabel('Color coherence (\%)') plot.ylabel('Choice to green (\%)') #--------------------------------------------------------------------------------- # Plot #--------------------------------------------------------------------------------- trialsfile = get_trialsfile(p) psychometric_function(trialsfile, plots) # Legend prop = {'prop': {'size': 7}, 'handlelength': 1.2, 'handletextpad': 1.1, 'labelspacing': 0.5} plots['m'].legend(bbox_to_anchor=(0.41, 1), **prop) #--------------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name']+'_'+action) fig.close() #------------------------------------------------------------------------------------- # Sort #------------------------------------------------------------------------------------- elif action == 'sort': trialsfile = get_trialsfile(p) sortedfile = get_sortedfile(p) sort_trials(trialsfile, sortedfile) #------------------------------------------------------------------------------------- # Plot single-unit activity #------------------------------------------------------------------------------------- elif action == 'units': from glob import glob # Remove existing files print("[ {}.do ]".format(THIS)) filenames = glob('{}_unit*'.format(join(p['figspath'], p['name']))) for filename in filenames: os.remove(filename) print(" Removed {}".format(filename)) trialsfile = get_trialsfile(p) sortedfile = get_sortedfile(p) units = get_active_units(trialsfile) for unit in units: #----------------------------------------------------------------------------- # Figure setup #----------------------------------------------------------------------------- w = 2.5 h = 6 fig = Figure(w=w, h=h, axislabelsize=7.5, labelpadx=6, labelpady=7.5, thickness=0.6, ticksize=3, ticklabelsize=6.5, ticklabelpad=2) w = 0.55 x0 = 0.3 h = 0.17 dy = h + 0.06 y0 = 0.77 y1 = y0 - dy y2 = y1 - dy y3 = y2 - dy plots = { 'choice': fig.add([x0, y0, w, h]), 'motion_choice': fig.add([x0, y1, w, h]), 'colour_choice': fig.add([x0, y2, w, h]), 'context_choice': fig.add([x0, y3, w, h]) } #----------------------------------------------------------------------------- # Plot #----------------------------------------------------------------------------- plot_unit(unit, sortedfile, plots, sortby_fontsize=7) plots['context_choice'].xlabel('Time (ms)') #----------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name']+'_unit{:03d}'.format(unit)) fig.close() print("[ {}.do ] {} units processed.".format(THIS, len(units))) #------------------------------------------------------------------------------------- # Regress #------------------------------------------------------------------------------------- elif action == 'regress': trialsfile = get_trialsfile(p) sortedfile = get_sortedfile(p) betafile = get_betafile(p) regress(trialsfile, sortedfile, betafile) #------------------------------------------------------------------------------------- else: print("[ {}.do ] Unrecognized action.".format(THIS))
'rdm_rt_trials.pkl') rt_sortedfile = join(paper.scratchpath, 'rdm_rt', 'trials', 'rdm_rt_sorted_response.pkl') varstim_unit = 10 rt_unit = 68 #========================================================================================= # Figure setup #========================================================================================= fig = Figure(w=4.3, h=6.6, axislabelsize=7, labelpadx=5, labelpady=5, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) w = 0.35 dx = 0.49 x0 = 0.12 x1 = x0 + dx h = 0.17 dy = 0.215 y0 = 0.775 y1 = y0 - dy y2 = y1 - dy - 0.03
dprime_dense = join(datapath, 'rdm_dense', 'rdm_dense_dprime.txt') sortby_dense = join(datapath, 'rdm_dense', 'rdm_dense_selectivity.txt') savefile = join(datapath, 'rdm_fixed', 'rdm_fixed.pkl') rnn_fixed = RNN(savefile, verbose=True) dprime_fixed = join(datapath, 'rdm_fixed', 'rdm_fixed_dprime.txt') sortby_fixed = join(datapath, 'rdm_fixed', 'rdm_fixed_selectivity.txt') #========================================================================================= # Figure setup #========================================================================================= w = 7.5 h = 4.7 r = w/h fig = Figure(w=w, h=h, axislabelsize=7, labelpadx=6, labelpady=6, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) w_rec = 0.25 h_rec = r*w_rec w_in = 0.03 h_in = h_rec w_out = w_rec h_out = r*w_in hspace = 0.013 vspace = r*hspace dx = 0.03 x0 = 0.035
trialsfile = join(paper.scratchpath, 'mante_areas', 'trials', 'mante_areas_trials.pkl') sortedfile = join(paper.scratchpath, 'mante_areas', 'trials', 'mante_areas_sorted.pkl') betafile = join(base, 'examples', 'work', 'data', 'mante_areas', 'mante_areas_beta.pkl') units = [10, 23, 25, 28] #========================================================================================= # Figure setup #========================================================================================= w = 7.5 h = 6.7 r = w/h fig = Figure(w=w, h=h, axislabelsize=6.5, labelpadx=5, labelpady=5, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) #----------------------------------------------------------------------------------------- # Psychometric functions #----------------------------------------------------------------------------------------- w_psy = 0.16 dx_psy = w_psy + 0.07 x_psy = 0.08 h_psy = 0.15 dy_psy = h_psy + 0.07 y_psy_m = 0.8 y_psy_c = y_psy_m - dy_psy
def plot_trial(trial_info, trial, figspath, name): U, Z, A, R, M, init, states_0, perf = trial_info U = U[:,0,:] Z = Z[:,0,:] A = A[:,0,:] R = R[:,0] M = M[:,0] t = int(np.sum(M)) w = 0.65 h = 0.18 x = 0.17 dy = h + 0.05 y0 = 0.08 y1 = y0 + dy y2 = y1 + dy y3 = y2 + dy fig = Figure(h=6) plots = {'observables': fig.add([x, y3, w, h]), 'policy': fig.add([x, y2, w, h]), 'actions': fig.add([x, y1, w, h]), 'rewards': fig.add([x, y0, w, h])} time = trial['time'] dt = time[1] - time[0] act_time = time[:t] obs_time = time[:t-1] + dt reward_time = act_time + dt xlim = (0, max(time)) #------------------------------------------------------------------------------------- # Observables #------------------------------------------------------------------------------------- plot = plots['observables'] plot.plot(obs_time, U[:t-1,0], 'o', ms=5, mew=0, mfc=Figure.colors('blue')) plot.plot(obs_time, U[:t-1,0], lw=1.25, color=Figure.colors('blue'), label='Keydown') plot.plot(obs_time, U[:t-1,1], 'o', ms=5, mew=0, mfc=Figure.colors('orange')) plot.plot(obs_time, U[:t-1,1], lw=1.25, color=Figure.colors('orange'), label=r'$f_\text{pos}$') plot.plot(obs_time, U[:t-1,2], 'o', ms=5, mew=0, mfc=Figure.colors('purple')) plot.plot(obs_time, U[:t-1,2], lw=1.25, color=Figure.colors('purple'), label=r'$f_\text{neg}$') plot.xlim(*xlim) plot.ylim(0, 1) plot.ylabel('Observables') if trial['gt_lt'] == '>': f1, f2 = trial['fpair'] else: f2, f1 = trial['fpair'] plot.text_upper_right(str((f1, f2))) #coh = trial['left_right']*trial['coh'] #if coh < 0: # color = Figure.colors('orange') #elif coh > 0: # color = Figure.colors('purple') #else: # color = Figure.colors('k') #plot.text_upper_right('Coh = {:.1f}\%'.format(coh), color=color) props = {'prop': {'size': 7}, 'handlelength': 1.2, 'handletextpad': 1.2, 'labelspacing': 0.8} plot.legend(bbox_to_anchor=(1.2, 0.8), **props) #------------------------------------------------------------------------------------- # Policy #------------------------------------------------------------------------------------- plot = plots['policy'] plot.plot(act_time, Z[:t,0], 'o', ms=5, mew=0, mfc=Figure.colors('blue')) plot.plot(act_time, Z[:t,0], lw=1.25, color=Figure.colors('blue'), label='Keydown') plot.plot(act_time, Z[:t,1], 'o', ms=5, mew=0, mfc=Figure.colors('orange')) plot.plot(act_time, Z[:t,1], lw=1.25, color=Figure.colors('orange'), label='$f_1 > f_2$') plot.plot(act_time, Z[:t,2], 'o', ms=5, mew=0, mfc=Figure.colors('purple')) plot.plot(act_time, Z[:t,2], lw=1.25, color=Figure.colors('purple'), label='$f_1 < f_2$') plot.xlim(*xlim) plot.ylim(0, 1) plot.ylabel('Action probabilities') props = {'prop': {'size': 7}, 'handlelength': 1.2, 'handletextpad': 1.2, 'labelspacing': 0.8} plot.legend(bbox_to_anchor=(1.27, 0.8), **props) #------------------------------------------------------------------------------------- # Actions #------------------------------------------------------------------------------------- plot = plots['actions'] actions = [np.argmax(a) for a in A[:t]] plot.plot(act_time, actions, 'o', ms=5, mew=0, mfc=Figure.colors('red')) plot.plot(act_time, actions, lw=1.25, color=Figure.colors('red')) plot.xlim(*xlim) plot.ylim(0, 2) plot.yticks([0, 1, 2]) plot.yticklabels(['Keydown', '$f_1 > f_2$', '$f_1 < f_2$']) plot.ylabel('Action') #------------------------------------------------------------------------------------- # Rewards #------------------------------------------------------------------------------------- plot = plots['rewards'] plot.plot(reward_time, R[:t], 'o', ms=5, mew=0, mfc=Figure.colors('red')) plot.plot(reward_time, R[:t], lw=1.25, color=Figure.colors('red')) plot.xlim(*xlim) plot.ylim(R_TERMINATE, R_CORRECT) plot.xlabel('Time (ms)') plot.ylabel('Reward') #------------------------------------------------------------------------------------- fig.save(path=figspath, name=name) fig.close()
from pycog import tasktools from pycog import RNN from pycog.figtools import Figure m = imp.load_source('model', 'romo.py') rng = np.random.RandomState(1066) rnn = RNN('romo_savefile.pkl', {'dt': 2}) trial_args = {'name': 'test', 'catch': False, 'fpair': (34, 26), 'gt_lt': '>'} info = rnn.run(inputs=(m.generate_trial, trial_args), rng=rng) fig = Figure() plot = fig.add() epochs = info['epochs'] f1_start, f1_end = epochs['f1'] f2_start, f2_end = epochs['f2'] t0 = f1_start tmin = 0 tmax = f2_end t = 1e-3 * (rnn.t - t0) delay = [1e-3 * (f1_end - t0), 1e-3 * (f2_start - t0)] yall = [] plot.plot(t, rnn.u[0], color=Figure.colors('orange'), lw=0.5) plot.plot(t, rnn.u[1], color=Figure.colors('blue'), lw=0.5)
rnn_fixed = RNN(savefile, verbose=True) dprime_fixed = join(datapath, 'rdm_fixed', 'rdm_fixed_dprime.txt') sortby_fixed = join(datapath, 'rdm_fixed', 'rdm_fixed_selectivity.txt') #========================================================================================= # Figure setup #========================================================================================= w = 7.5 h = 4.7 r = w / h fig = Figure(w=w, h=h, axislabelsize=7, labelpadx=6, labelpady=6, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) w_rec = 0.25 h_rec = r * w_rec w_in = 0.03 h_in = h_rec w_out = w_rec h_out = r * w_in hspace = 0.013
if 'init' in args: print("* Initial network.") base, ext = os.path.splitext(savefile) savefile_init = base + '_init' + ext rnn = RNN(savefile_init, {'dt': dt}, verbose=True) else: rnn = RNN(savefile, {'dt': dt}, verbose=True) rnn.run(3e3, seed=seed) # Summary mean = np.mean(rnn.z) std = np.std(rnn.z) print("Mean output: {:.6f}".format(mean)) print("Std. output: {:.6f}".format(std)) fig = Figure() plot = fig.add() colors = [Figure.colors('blue'), Figure.colors('orange')] for i in xrange(rnn.z.shape[0]): plot.plot(1e-3*rnn.t, rnn.z[i], color=colors[i%len(colors)]) mean = np.mean(rnn.z[i])*np.ones_like(rnn.t) plot.plot(1e-3*rnn.t, mean, color=colors[i%len(colors)]) plot.xlim(1e-3*rnn.t[0], 1e-3*rnn.t[-1]) plot.lim('y', np.ravel(rnn.z), lower=0) plot.xlabel('Time (sec)') plot.ylabel('Outputs') fig.save(path=figspath, name=name+'_'+action) fig.close()
norm = mpl.colors.Normalize(vmin=m.fmin, vmax=m.fmax) smap = mpl.cm.ScalarMappable(norm, cmap) # ========================================================================================= # Figure setup # ========================================================================================= w = 6.3 h = 4 r = w / h fig = Figure( w=w, h=h, axislabelsize=7, labelpadx=5, labelpady=5.5, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format, ) # ----------------------------------------------------------------------------------------- # Inputs # ----------------------------------------------------------------------------------------- w = 0.25 dx = w + 0.04 x0 = 0.09 h = 0.165
min_error = 0.1 n_validation = 100 if __name__ == '__main__': from pycog import RNN from pycog.figtools import Figure rnn = RNN('work/data/multi_sequence3mod/multi_sequence3mod.pkl', {'dt': 0.5, 'var_rec': 0.01**2, 'var_in': np.array([0.003**2])}) trial_args = {} info = rnn.run(inputs=(generate_trial, trial_args), seed=7449) fig = Figure() plot = fig.add() colors = ['red', 'green', 'yellow', 'orange', 'purple', 'cyan', 'magenta', 'pink'] plot.plot(rnn.t/tau, rnn.u[0], color=Figure.colors('blue')) for i in range(Nout): plot.plot(rnn.t/tau, rnn.z[i], color=Figure.colors(colors[int(i / NoutSplit)])) plot.xlim(rnn.t[0]/tau, rnn.t[-1]/tau) plot.ylim(0, 15) Nexc = int(N * 0.8) plot.plot(rnn.t/tau, rnn.r[:Nexc].mean(axis=0), color=Figure.colors("pink")) plot.plot(rnn.t/tau, rnn.r[Nexc:].mean(axis=0), color=Figure.colors("magenta")) plot.xlabel(r'$t/\tau$')
def do(action, args, p): print("ACTION*: " + str(action)) print("ARGS*: " + str(args)) #------------------------------------------------------------------------------------- # Trials #------------------------------------------------------------------------------------- if action == 'trials': run_trials(p, args) #------------------------------------------------------------------------------------- # Psychometric function #------------------------------------------------------------------------------------- elif action == 'psychometric': #--------------------------------------------------------------------------------- # Figure setup #--------------------------------------------------------------------------------- w = 6.5 h = 3 fig = Figure(w=w, h=h, axislabelsize=7.5, labelpadx=6, labelpady=7.5, thickness=0.6, ticksize=3, ticklabelsize=6.5, ticklabelpad=2) w = 0.39 h = 0.7 L = 0.09 R = L + w + 0.1 y = 0.2 plots = {'m': fig.add([L, y, w, h]), 'c': fig.add([R, y, w, h])} #--------------------------------------------------------------------------------- # Labels #--------------------------------------------------------------------------------- plot = plots['m'] plot.xlabel('Motion coherence (\%)') plot.ylabel('Choice to right (\%)') plot = plots['c'] plot.xlabel('Color coherence (\%)') plot.ylabel('Choice to green (\%)') #--------------------------------------------------------------------------------- # Plot #--------------------------------------------------------------------------------- trialsfile = get_trialsfile(p) psychometric_function(trialsfile, plots) # Legend prop = { 'prop': { 'size': 7 }, 'handlelength': 1.2, 'handletextpad': 1.1, 'labelspacing': 0.5 } plots['m'].legend(bbox_to_anchor=(0.41, 1), **prop) #--------------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name'] + '_' + action) fig.close() #------------------------------------------------------------------------------------- # Sort #------------------------------------------------------------------------------------- elif action == 'sort': trialsfile = get_trialsfile(p) sortedfile = get_sortedfile(p) sort_trials(trialsfile, sortedfile) #------------------------------------------------------------------------------------- # Plot single-unit activity #------------------------------------------------------------------------------------- elif action == 'units': from glob import glob # Remove existing files print("[ {}.do ]".format(THIS)) filenames = glob('{}_unit*'.format(join(p['figspath'], p['name']))) for filename in filenames: os.remove(filename) print(" Removed {}".format(filename)) trialsfile = get_trialsfile(p) sortedfile = get_sortedfile(p) units = get_active_units(trialsfile) for unit in units: #----------------------------------------------------------------------------- # Figure setup #----------------------------------------------------------------------------- w = 2.5 h = 6 fig = Figure(w=w, h=h, axislabelsize=7.5, labelpadx=6, labelpady=7.5, thickness=0.6, ticksize=3, ticklabelsize=6.5, ticklabelpad=2) w = 0.55 x0 = 0.3 h = 0.17 dy = h + 0.06 y0 = 0.77 y1 = y0 - dy y2 = y1 - dy y3 = y2 - dy plots = { 'choice': fig.add([x0, y0, w, h]), 'motion_choice': fig.add([x0, y1, w, h]), 'colour_choice': fig.add([x0, y2, w, h]), 'context_choice': fig.add([x0, y3, w, h]) } #----------------------------------------------------------------------------- # Plot #----------------------------------------------------------------------------- plot_unit(unit, sortedfile, plots, sortby_fontsize=7) plots['context_choice'].xlabel('Time (ms)') #----------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name'] + '_unit{:03d}'.format(unit)) fig.close() print("[ {}.do ] {} units processed.".format(THIS, len(units))) #------------------------------------------------------------------------------------- # Regress #------------------------------------------------------------------------------------- elif action == 'regress': trialsfile = get_trialsfile(p) sortedfile = get_sortedfile(p) betafile = get_betafile(p) regress(trialsfile, sortedfile, betafile) #------------------------------------------------------------------------------------- else: print("[ {}.do ] Unrecognized action.".format(THIS))
def do(action, args, p): """ Manage tasks. """ print("ACTION*: " + str(action)) print("ARGS*: " + str(args)) #------------------------------------------------------------------------------------- # Trials #------------------------------------------------------------------------------------- if action == 'trials': run_trials(p, args) #------------------------------------------------------------------------------------- # Psychometric function #------------------------------------------------------------------------------------- elif action == 'psychometric': fig = Figure() plot = fig.add() #--------------------------------------------------------------------------------- # Plot #--------------------------------------------------------------------------------- trialsfile = get_trialsfile(p) psychometric_function(trialsfile, plot) plot.xlabel(r'Rate (events/sec)') plot.ylabel(r'Percent high') #--------------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name'] + '_' + action) fig.close() #------------------------------------------------------------------------------------- # Sort #------------------------------------------------------------------------------------- elif action == 'sort': trialsfile = get_trialsfile(p) sortedfile = get_sortedfile(p) sort_trials(trialsfile, sortedfile) #------------------------------------------------------------------------------------- # Plot single-unit activity #------------------------------------------------------------------------------------- elif action == 'units': from glob import glob # Remove existing files print("[ {}.do ]".format(THIS)) filenames = glob('{}_unit*'.format(join(p['figspath'], p['name']))) for filename in filenames: os.remove(filename) print(" Removed {}".format(filename)) # Load sorted trials sortedfile = get_sortedfile(p) with open(sortedfile) as f: t, sorted_trials = pickle.load(f) for i in xrange(p['model'].N): # Check if the unit does anything active = False for r in sorted_trials.values(): if is_active(r[i]): active = True break if not active: continue fig = Figure() plot = fig.add() #--------------------------------------------------------------------------------- # Plot #--------------------------------------------------------------------------------- plot_unit(i, sortedfile, plot) plot.xlabel('Time (ms)') plot.ylabel('Firing rate (a.u.)') #--------------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name'] + '_unit{:03d}'.format(i)) fig.close() #------------------------------------------------------------------------------------- else: print("[ {}.do ] Unrecognized action.".format(THIS))
def do(action, args, p): """ Manage tasks. """ print("ACTION*: " + str(action)) print("ARGS*: " + str(args)) #------------------------------------------------------------------------------------- # Trials #------------------------------------------------------------------------------------- if action == 'trials': run_trials(p, args) #------------------------------------------------------------------------------------- # Psychometric function #------------------------------------------------------------------------------------- elif action == 'psychometric': threshold = False if 'threshold' in args: threshold = True fig = Figure() plot = fig.add() #--------------------------------------------------------------------------------- # Plot #--------------------------------------------------------------------------------- trialsfile = get_trialsfile(p) psychometric_function(trialsfile, plot, threshold=threshold) plot.xlabel(r'Percent coherence toward $T_\text{in}$') plot.ylabel(r'Percent $T_\text{in}$') #--------------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name']+'_'+action) fig.close() #------------------------------------------------------------------------------------- # Sort #------------------------------------------------------------------------------------- elif action == 'sort_stim_onset': sort_trials_stim_onset(get_trialsfile(p), get_sortedfile_stim_onset(p)) elif action == 'sort_response': sort_trials_response(get_trialsfile(p), get_sortedfile_response(p)) #------------------------------------------------------------------------------------- # Plot single-unit activity aligned to stimulus onset #------------------------------------------------------------------------------------- elif action == 'units_stim_onset': from glob import glob # Remove existing files filenames = glob(join(p['figspath'], p['name'] + '_stim_onset_unit*')) for filename in filenames: os.remove(filename) print("Removed {}".format(filename)) # Load sorted trials sortedfile = get_sortedfile_stim_onset(p) with open(sortedfile) as f: t, sorted_trials = pickle.load(f) for i in xrange(p['model'].N): # Check if the unit does anything active = False for r in sorted_trials.values(): if is_active(r[i]): active = True break if not active: continue fig = Figure() plot = fig.add() #----------------------------------------------------------------------------- # Plot #----------------------------------------------------------------------------- plot_unit(i, sortedfile, plot) plot.xlabel('Time (ms)') plot.ylabel('Firing rate (a.u.)') props = {'prop': {'size': 8}, 'handletextpad': 1.02, 'labelspacing': 0.6} plot.legend(bbox_to_anchor=(0.18, 1), **props) #----------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name']+'_stim_onset_unit{:03d}'.format(i)) fig.close() #------------------------------------------------------------------------------------- # Plot single-unit activity aligned to response #------------------------------------------------------------------------------------- elif action == 'units_response': from glob import glob # Remove existing files filenames = glob(join(p['figspath'], p['name'] + '_response_unit*')) for filename in filenames: os.remove(filename) print("Removed {}".format(filename)) # Load sorted trials sortedfile = get_sortedfile_response(p) with open(sortedfile) as f: t, sorted_trials = pickle.load(f) for i in xrange(p['model'].N): # Check if the unit does anything active = False for r in sorted_trials.values(): if is_active(r[i]): active = True break if not active: continue fig = Figure() plot = fig.add() #----------------------------------------------------------------------------- # Plot #----------------------------------------------------------------------------- plot_unit(i, sortedfile, plot) plot.xlabel('Time (ms)') plot.ylabel('Firing rate (a.u.)') props = {'prop': {'size': 8}, 'handletextpad': 1.02, 'labelspacing': 0.6} plot.legend(bbox_to_anchor=(0.18, 1), **props) #----------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name']+'_response_unit_{:03d}'.format(i)) fig.close() #------------------------------------------------------------------------------------- # Selectivity #------------------------------------------------------------------------------------- elif action == 'selectivity': # Model m = p['model'] trialsfile = get_trialsfile(p) dprime = get_choice_selectivity(trialsfile) def get_first(x, p): return x[:int(p*len(x))] psig = 0.25 units = np.arange(len(dprime)) try: idx = np.argsort(abs(dprime[m.EXC]))[::-1] exc = get_first(units[m.EXC][idx], psig) idx = np.argsort(abs(dprime[m.INH]))[::-1] inh = get_first(units[m.INH][idx], psig) idx = np.argsort(dprime[exc])[::-1] units_exc = list(exc[idx]) idx = np.argsort(dprime[inh])[::-1] units_inh = list(units[inh][idx]) units = units_exc + units_inh dprime = dprime[units] except AttributeError: idx = np.argsort(abs(dprime))[::-1] all = get_first(units[idx], psig) idx = np.argsort(dprime[all])[::-1] units = list(units[all][idx]) dprime = dprime[units] # Save d' filename = get_dprimefile(p) np.savetxt(filename, dprime) print("[ {}.do ] d\' saved to {}".format(THIS, filename)) # Save selectivity filename = get_selectivityfile(p) np.savetxt(filename, units, fmt='%d') print("[ {}.do ] Choice selectivity saved to {}".format(THIS, filename)) #------------------------------------------------------------------------------------- else: print("[ {}.do ] Unrecognized action.".format(THIS))
def tuning_corr(trialsfile, sortedfile, plot_sig, plot_corr=None, plot_stim=None, plot_delay=None, t0=0, **kwargs): """ Plot correlation of a1 between different times. """ units, a1s, pvals = tuning(sortedfile) # Get first trial trials, _ = load_trials(trialsfile) trial = trials[0] info = trial['info'] t = trial['t'] _, delay_end = info['epochs']['delay'] delay_end = 1e-3*(delay_end - t0) t_stim = np.mean(info['epochs']['f1']) idx_stim = np.where(t >= t_stim)[0][0] t_delay = np.mean(info['epochs']['delay']) idx_delay = np.where(t >= t_delay)[0][0] t_delay_end = info['epochs']['delay'][1] idx_delay_end = np.where(t > t_delay_end)[0][0] t_f2_end = info['epochs']['f2'][1] idx_f2_end = np.where(t > t_f2_end)[0][0] t_all = 1e-3*(t[idx_stim:idx_delay_end]-t0) idx_all = np.arange(len(t))[idx_stim:idx_delay_end] # Plot correlation across time if plot_corr is not None: plot = plot_corr # With stimulus period corr = [] for k in idx_all: corr.append(stats.pearsonr(a1s[:,idx_stim], a1s[:,k])[0]) plot.plot(t_all, corr, color=Figure.colors('blue'), lw=kwargs.get('lw', 1)) # With stimulus period corr = [] for k in idx_all: corr.append(stats.pearsonr(a1s[:,idx_delay], a1s[:,k])[0]) plot.plot(t_all, corr, color=Figure.colors('green'), lw=kwargs.get('lw', 1)) plot.xlim(-1e-3*t0, delay_end) plot.ylim(-1, 1) # Plot fraction of significantly tuned units. if plot_sig is not None: plot = plot_sig psig = np.sum(1*(pvals < 0.05), axis=0)/len(units) plot.plot(1e-3*(t[1:idx_f2_end]-t0), psig[1:idx_f2_end], color='0.2', lw=kwargs.get('lw', 1)) plot.xlim(1e-3*(t[0]-t0), 1e-3*(t[idx_f2_end-1]-t0)) #plot.lim('y', psig, lower=0) plot.ylim(0, 1) # Shared plot properties prop = {'mfc': '0.2', 'mec': 'none', 'ms': kwargs.get('ms', 2)} # Plot a1, end of delay vs. stimulus if plot_stim is not None: plot = plot_stim plot.equal() for i in xrange(len(units)): plot.plot(a1s[i,idx_stim], a1s[i,idx_delay_end], 'o', **prop) # Plot a1, end of delay vs. middle of delay if plot_delay is not None: plot = plot_delay plot.equal() for i in xrange(len(units)): plot.plot(a1s[i,idx_delay], a1s[i,idx_delay_end], 'o', **prop)
# Load model modelfile = join(base, 'examples', 'models', 'multisensory.py') m = imp.load_source('model', modelfile) # Units to display units = { 'choice': 87, 'modality': 123, 'mixed': 121 } #========================================================================================= # Figure setup #========================================================================================= fig = Figure(w=6.3, h=3.9, axislabelsize=7, labelpadx=5, labelpady=5.5, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) #----------------------------------------------------------------------------------------- # Inputs #----------------------------------------------------------------------------------------- w = 0.15 dx = w + 0.04 x0 = 0.09 x1 = x0 + dx x2 = x1 + dx h = 0.15 dy = h + 0.05 y0 = 0.79 y1 = y0 - dy
# File to store sorted trials in def get_sortedfile(p): return join(p['trialspath'], p['name'] + '_sorted.pkl') # Simple choice function def get_choice(trial): return np.argmax(trial['z'][:,-1]) # Define "active" units def is_active(r): return np.std(r) > 0.05 # Colors colors = { 'v': Figure.colors('blue'), 'a': Figure.colors('green'), 'va': Figure.colors('orange') } #========================================================================================= def run_trials(p, args): """ Run trials. """ # Model m = p['model'] # Number of trials
def plot_unit(unit, sortedfile, plots, t0=0, tmin=-np.inf, tmax=np.inf, **kwargs): # Load sorted trials with open(sortedfile, 'rb') as f: t, sorted_trials = pickle.load(f) #------------------------------------------------------------------------------------- # Labels #------------------------------------------------------------------------------------- # Unit no. fontsize = kwargs.get('unit_fontsize', 7) plots['choice'].text_upper_center('Unit ' + str(unit), dy=0.07, fontsize=fontsize) # Sort-by if kwargs.get('sortby_fontsize') is not None: fontsize = kwargs['sortby_fontsize'] labels = { 'choice': 'choice', 'motion_choice': 'motion \& choice', 'colour_choice': 'color \& choice', 'context_choice': 'context \& choice' } for k, label in labels.items(): plots[k].ylabel(label) #------------------------------------------------------------------------------------- # Setup #------------------------------------------------------------------------------------- # Duration to plot w, = np.where((tmin <= t) & (t <= tmax)) t = t - t0 # Linestyle def get_linestyle(choice): if choice == +1: return '-' return '--' # Line width lw = kwargs.get('lw', 1) # For setting axis limits yall = [] #------------------------------------------------------------------------------------- # Choice #------------------------------------------------------------------------------------- plot = plots['choice'] condition_averaged = sorted_trials['choice'] for (choice, ), r in condition_averaged.items(): ls = get_linestyle(choice) plot.plot(t[w], r[unit, w], ls, color=Figure.colors('red'), lw=lw) yall.append(r[unit, w]) plot.xlim(t[w][0], t[w][-1]) plot.xticks([t[w][0], 0, t[w][-1]]) #------------------------------------------------------------------------------------- # Motion & choice #------------------------------------------------------------------------------------- plot = plots['motion_choice'] condition_averaged = sorted_trials['motion_choice'] abscohs = [] for (choice, coh, context) in condition_averaged: abscohs.append(abs(coh)) abscohs = sorted(list(set(abscohs))) for (choice, coh, context), r in condition_averaged.items(): if context != 'm': continue ls = get_linestyle(choice) idx = abscohs.index(abs(coh)) basecolor = 'k' if idx == 0: color = apply_alpha(basecolor, 0.4) elif idx == 1: color = apply_alpha(basecolor, 0.7) else: color = apply_alpha(basecolor, 1) plot.plot(t[w], r[unit, w], ls, color=color, lw=lw) yall.append(r[unit, w]) plot.xlim(t[w][0], t[w][-1]) plot.xticks([t[w][0], 0, t[w][-1]]) #------------------------------------------------------------------------------------- # Colour & choice #------------------------------------------------------------------------------------- plot = plots['colour_choice'] condition_averaged = sorted_trials['colour_choice'] abscohs = [] for (choice, coh, context) in condition_averaged: abscohs.append(abs(coh)) abscohs = sorted(list(set(abscohs))) for (choice, coh, context), r in condition_averaged.items(): if context != 'c': continue ls = get_linestyle(choice) idx = abscohs.index(abs(coh)) basecolor = Figure.colors('darkblue') if idx == 0: color = apply_alpha(basecolor, 0.4) elif idx == 1: color = apply_alpha(basecolor, 0.7) else: color = apply_alpha(basecolor, 1) plot.plot(t[w], r[unit, w], ls, color=color, lw=lw) yall.append(r[unit, w]) plot.xlim(t[w][0], t[w][-1]) plot.xticks([t[w][0], 0, t[w][-1]]) #------------------------------------------------------------------------------------- # Context & choice #------------------------------------------------------------------------------------- plot = plots['context_choice'] condition_averaged = sorted_trials['context_choice'] for (choice, context), r in condition_averaged.items(): ls = get_linestyle(choice) if context == 'm': color = 'k' else: color = Figure.colors('darkblue') plot.plot(t[w], r[unit, w], ls, color=color, lw=lw) yall.append(r[unit, w]) plot.xlim(t[w][0], t[w][-1]) plot.xticks([t[w][0], 0, t[w][-1]]) return yall
trial_func = m.generate_trial trial_args = { 'name': 'test', 'catch': False, 'coh': 16, 'in_out': 1 } info = rnn.run(inputs=(trial_func, trial_args), seed=10) colors = ['orange', 'purple'] DT = 15 # Inputs for i, clr in enumerate(colors): fig = Figure(w=2, h=1) plot = fig.add(None, 'none') plot.plot(rnn.t[::DT], rnn.u[i][::DT], color=Figure.colors(clr), lw=1) plot.ylim(0, 1.5) fig.save(path=figspath, name='fig1a_input{}'.format(i+1)) fig.close() # Outputs for i, clr in enumerate(colors): fig = Figure(w=2, h=1) plot = fig.add(None, 'none') plot.plot(rnn.t[::DT], rnn.z[i][::DT], color=Figure.colors(clr), lw=1) plot.ylim(0, 1.5)
def do(action, args, p): """ Manage tasks. """ print("ACTION*: " + str(action)) print("ARGS*: " + str(args)) #------------------------------------------------------------------------------------- # Trials #------------------------------------------------------------------------------------- if action == 'trials': run_trials(p, args) #------------------------------------------------------------------------------------- # Psychometric function #------------------------------------------------------------------------------------- elif action == 'psychometric': fig = Figure() plot = fig.add() #--------------------------------------------------------------------------------- # Plot #--------------------------------------------------------------------------------- trialsfile = get_trialsfile(p) psychometric_function(trialsfile, plot) plot.xlabel('$f_1$ (Hz)') plot.ylabel('$f_2$ (Hz)') #--------------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name'] + '_' + action) fig.close() #------------------------------------------------------------------------------------- # Sort #------------------------------------------------------------------------------------- elif action == 'sort': sort_trials(get_trialsfile(p), get_sortedfile(p)) #------------------------------------------------------------------------------------- # Plot single-unit activity aligned to stimulus onset #------------------------------------------------------------------------------------- elif action == 'units': from glob import glob # Remove existing files print("[ {}.do ]".format(THIS)) filenames = glob('{}_unit*'.format(join(p['figspath'], p['name']))) for filename in filenames: os.remove(filename) print(" Removed {}".format(filename)) # Load sorted trials sortedfile = get_sortedfile(p) with open(sortedfile) as f: t, sorted_trials = pickle.load(f) # Colormap cmap = mpl.cm.jet norm = mpl.colors.Normalize(vmin=p['model'].fmin, vmax=p['model'].fmax) smap = mpl.cm.ScalarMappable(norm, cmap) for i in xrange(p['model'].N): # Check if the unit does anything active = False for condition_averaged in sorted_trials.values(): if is_active(condition_averaged[i]): active = True break if not active: continue fig = Figure() plot = fig.add() #----------------------------------------------------------------------------- # Plot #----------------------------------------------------------------------------- plot_unit(i, sortedfile, plot, smap) plot.xlabel('Time (ms)') plot.ylabel('Firing rate (a.u.)') props = { 'prop': { 'size': 8 }, 'handletextpad': 1.02, 'labelspacing': 0.6 } plot.legend(bbox_to_anchor=(0.18, 1), **props) #----------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name'] + '_unit{:03d}'.format(i)) fig.close() #------------------------------------------------------------------------------------- else: print("[ {}.do ] Unrecognized action '{}'.".format(THIS, action))
('rdm_rt', '2B: Decision-making (reaction-time)'), ('rdm_nodale', '3A: Decision-making (no Dale)'), ('rdm_dense', '3B: Decision-making (Dale, dense)'), ('rdm_fixed', '3C: Decision-making (Dale, fixed)'), ('mante', '4: Context-dependent int.'), ('mante_areas', '5B: Context-dependent int. (areas)'), ('multisensory', '6: Multisensory int.'), ('romo', '7: Parametric working memory'), ('lee', '8: Lee')] labels = list('ABCDEFGHIJ') #========================================================================================= # Figure setup #========================================================================================= fig = Figure(w=3.8, h=6.75, axislabelsize=6.5, labelpadx=4, labelpady=3, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) ncols = 2 nrows = 5 w = 0.36 dx = w + 0.12 x0 = 0.12 xall = x0 + dx*np.arange(ncols) h = 0.13 y0 = 0.82 dy = h + 0.06 yall = y0 - dy*np.arange(nrows) plots = {}
def psychometric_function(trialsfile, plots=None, **kwargs): """ Psychometric function. """ # Load trials trials, ntrials = load_trials(trialsfile) #------------------------------------------------------------------------------------- # Compute psychometric function #------------------------------------------------------------------------------------- results = {cond: {} for cond in ['mm', 'mc', 'cm', 'cc']} ncorrect = 0 for trial in trials: info = trial['info'] coh_m = info['left_right_m'] * info['coh_m'] coh_c = info['left_right_c'] * info['coh_c'] choice = get_choice(trial) if choice == info['choice']: ncorrect += 1 if info['context'] == 'm': results['mm'].setdefault(coh_m, []).append(choice) results['mc'].setdefault(coh_c, []).append(choice) else: results['cm'].setdefault(coh_m, []).append(choice) results['cc'].setdefault(coh_c, []).append(choice) print("[ {}.psychometric_function ] {:.2f}% correct.".format( THIS, 100 * ncorrect / ntrials)) for cond in results: choice_by_coh = results[cond] cohs = np.sort(np.array(choice_by_coh.keys())) p0 = np.zeros(len(cohs)) for i, coh in enumerate(cohs): choices = np.array(choice_by_coh[coh]) p0[i] = 1 - np.sum(choices) / len(choices) scaled_cohs = SCALE * cohs results[cond] = (scaled_cohs, p0) #------------------------------------------------------------------------------------- # Plot #------------------------------------------------------------------------------------- if plots is not None: ms = kwargs.get('ms', 5) color_m = '0.2' color_c = Figure.colors('darkblue') for cond, result in results.items(): # Context if cond[0] == 'm': color = color_m label = 'Motion context' else: color = color_c label = 'Color context' # Stimulus if cond[1] == 'm': plot = plots['m'] else: plot = plots['c'] # Result scaled_cohs, p0 = result # Data points plot.plot(scaled_cohs, 100 * p0, 'o', ms=ms, mew=0, mfc=color, zorder=10) # Fit try: popt, func = fittools.fit_psychometric(scaled_cohs, p0) fit_cohs = np.linspace(min(scaled_cohs), max(scaled_cohs), 201) fit_p0 = func(fit_cohs, **popt) plot.plot(fit_cohs, 100 * fit_p0, color=color, lw=1, zorder=5, label=label) except RuntimeError: print("[ {}.psychometric_function ]".format(THIS) + " Unable to fit, drawing a line through the points.") plot.plot(scaled_cohs, 100 * p0, color=color, lw=1, zorder=5, label=label) plot.lim('x', scaled_cohs) plot.ylim(0, 100) #------------------------------------------------------------------------------------- return results
model = Model(N=N, Nout=Nout, ei=ei, tau=tau, dt=dt, train_brec=train_brec, train_bout=train_bout, var_rec=var_rec, generate_trial=generate_trial, mode=mode, n_validation=n_validation, min_error=min_error) model.train('savefile.pkl', seed=100, recover=False) #------------------------------------------------------------------------------------- # Plot #------------------------------------------------------------------------------------- from pycog import RNN from pycog.figtools import Figure rnn = RNN('savefile.pkl', {'dt': 0.5, 'var_rec': 0.01**2}) info = rnn.run(T=2*period) fig = Figure() plot = fig.add() plot.plot(rnn.t/tau, rnn.z[0], color=Figure.colors('blue')) plot.xlim(rnn.t[0]/tau, rnn.t[-1]/tau) plot.ylim(0, 2) print rnn.t[0] print rnn.t[-1] plot.plot((rnn.t/tau)[:], (0.9*np.power(rnn.t/(2*period),2))[:],color=Figure.colors('orange')) plot.xlabel(r'$t/\tau$') plot.ylabel('$\sin t$') fig.save(path='.', name='xSquared')
def plot_statespace(trialsfile, sortedfile, betafile, plots): # Load trials trials, ntrials = load_trials(trialsfile) # Load sorted trials with open(sortedfile) as f: t, sorted_trials = pickle.load(f) # Load task axes with open(betafile) as f: M = pickle.load(f).T # Active units units = get_active_units(trialsfile) # Epoch to plot start, end = trials[0]['info']['epochs']['stimulus'] start += 0 end += 0 w, = np.where((start <= t) & (t <= end)) # Down-sample dt = t[1] - t[0] step = int(50 / dt) w = w[::step] # Colors color_m = 'k' color_c = Figure.colors('darkblue') xall = [] yall = [] #------------------------------------------------------------------------------------- # Labels #------------------------------------------------------------------------------------- plots['c1'].xlabel('Choice') #------------------------------------------------------------------------------------- # Motion context: motion vs. choice, sorted by coherence #------------------------------------------------------------------------------------- plot = plots['m1'] p_vc = {} for cond, r in sorted_trials['motion_choice'].items(): if cond[2] == 'm': p_vc[cond] = M.dot(r[units, :][:, w]) x, y = plot_taskaxes(plot, MOTION, p_vc, color_m) xall.append(x) yall.append(y) plot.ylabel('Motion') #------------------------------------------------------------------------------------- # Motion context: motion vs. choice, sorted by coherence #------------------------------------------------------------------------------------- plot = plots['m2'] p_vc = {} for cond, r in sorted_trials['motion_choice'].items(): if cond[2] == 'm': p_vc[cond] = M.dot(r[units, :][:, w]) x, y = plot_taskaxes(plot, COLOUR, p_vc, color_m) xall.append(x) yall.append(y) #------------------------------------------------------------------------------------- # Motion context: colour vs. choice, sorted by colour #------------------------------------------------------------------------------------- plot = plots['m3'] p_vc = {} for cond, r in sorted_trials['colour_choice'].items(): if cond[2] == 'm': p_vc[cond] = M.dot(r[units, :][:, w]) x, y = plot_taskaxes(plot, COLOUR, p_vc, color_c) xall.append(x) yall.append(y) #------------------------------------------------------------------------------------- # Colour context: motion vs. choice, sorted by motion #------------------------------------------------------------------------------------- plot = plots['c1'] p_vc = {} for cond, r in sorted_trials['motion_choice'].items(): if cond[2] == 'c': p_vc[cond] = M.dot(r[units, :][:, w]) x, y = plot_taskaxes(plot, MOTION, p_vc, color_m) xall.append(x) yall.append(y) #------------------------------------------------------------------------------------- # Colour context: motion vs. choice, sorted by colour #------------------------------------------------------------------------------------- plot = plots['c2'] p_vc = {} for cond, r in sorted_trials['colour_choice'].items(): if cond[2] == 'c': p_vc[cond] = M.dot(r[units, :][:, w]) x, y = plot_taskaxes(plot, MOTION, p_vc, color_c) xall.append(x) yall.append(y) #------------------------------------------------------------------------------------- # Colour context: colour vs. choice, sorted by colour #------------------------------------------------------------------------------------- plot = plots['c3'] p_vc = {} for cond, r in sorted_trials['colour_choice'].items(): if cond[2] == 'c': p_vc[cond] = M.dot(r[units, :][:, w]) x, y = plot_taskaxes(plot, COLOUR, p_vc, color_c) xall.append(x) yall.append(y) #------------------------------------------------------------------------------------- # Shared axes #------------------------------------------------------------------------------------- xall = np.concatenate(xall) yall = np.concatenate(yall) for plot in plots.values(): plot.aspect(1.5) plot.lim('x', xall) plot.lim('y', yall)
# Load model modelfile = join(base, 'examples', 'models', 'multisensory.py') m = imp.load_source('model', modelfile) # Units to display units = {'choice': 87, 'modality': 123, 'mixed': 121} #========================================================================================= # Figure setup #========================================================================================= fig = Figure(w=6.3, h=3.9, axislabelsize=7, labelpadx=5, labelpady=5.5, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) #----------------------------------------------------------------------------------------- # Inputs #----------------------------------------------------------------------------------------- w = 0.15 dx = w + 0.04 x0 = 0.09 x1 = x0 + dx x2 = x1 + dx
import numpy as np from pycog.figtools import Figure w = 174 / 25.4 r = 0.6 h = r * w fig = Figure(w=w, h=h) w = 0.4 h = 0.18 x0 = 0.07 y0 = 0.72 dx = 1.23 * w dy = 1.25 * h plots = { 'SL-f': fig.add([x0, y0, w, h]), 'SL-s': fig.add([x0, y0 - dy, w, h]), 'SL-e': fig.add([x0, y0 - 2 * dy, w, h], 'none'), 'SL-o': fig.add([x0, y0 - 3 * dy, w, h]), 'RL-f': fig.add([x0 + dx, y0, w, h]), 'RL-s': fig.add([x0 + dx, y0 - dy, w, h]), 'RL-e': fig.add([x0 + dx, y0 - 2 * dy, w, h], 'none'), 'RL-o': fig.add([x0 + dx, y0 - 3 * dy, w, h], 'none') } x0 = 0.01 x1 = x0 + dx y0 = 0.95 plotlabels = {'A': (x0, y0), 'B': (x1, y0)} fig.plotlabels(plotlabels, fontsize=12.5)
if 'init' in args: print("* Initial network.") base, ext = os.path.splitext(savefile) savefile_init = base + '_init' + ext rnn = RNN(savefile_init, {'dt': dt}, verbose=True) else: rnn = RNN(savefile, {'dt': dt}, verbose=True) rnn.run(3e3, seed=seed) # Summary mean = np.mean(rnn.z) std = np.std(rnn.z) print("Mean output: {:.6f}".format(mean)) print("Std. output: {:.6f}".format(std)) fig = Figure() plot = fig.add() colors = [Figure.colors('blue'), Figure.colors('orange')] for i in xrange(rnn.z.shape[0]): plot.plot(1e-3 * rnn.t, rnn.z[i], color=colors[i % len(colors)]) mean = np.mean(rnn.z[i]) * np.ones_like(rnn.t) plot.plot(1e-3 * rnn.t, mean, color=colors[i % len(colors)]) plot.xlim(1e-3 * rnn.t[0], 1e-3 * rnn.t[-1]) plot.lim('y', np.ravel(rnn.z), lower=0) plot.xlabel('Time (sec)') plot.ylabel('Outputs') fig.save(path=figspath, name=name + '_' + action) fig.close()
def do(action, args, p): """ Manage tasks. """ print("ACTION*: " + str(action)) print("ARGS*: " + str(args)) #------------------------------------------------------------------------------------- # Trials #------------------------------------------------------------------------------------- if action == 'trials': run_trials(p, args) #------------------------------------------------------------------------------------- # Psychometric function #------------------------------------------------------------------------------------- elif action == 'psychometric': threshold = False if 'threshold' in args: threshold = True fig = Figure() plot = fig.add() #--------------------------------------------------------------------------------- # Plot #--------------------------------------------------------------------------------- trialsfile = get_trialsfile(p) psychometric_function(trialsfile, plot, threshold=threshold) plot.xlabel(r'Percent coherence toward $T_\text{in}$') plot.ylabel(r'Percent $T_\text{in}$') #--------------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name'] + '_' + action) fig.close() #------------------------------------------------------------------------------------- # Sort #------------------------------------------------------------------------------------- elif action == 'sort_stim_onset': sort_trials_stim_onset(get_trialsfile(p), get_sortedfile_stim_onset(p)) elif action == 'sort_response': sort_trials_response(get_trialsfile(p), get_sortedfile_response(p)) #------------------------------------------------------------------------------------- # Plot single-unit activity aligned to stimulus onset #------------------------------------------------------------------------------------- elif action == 'units_stim_onset': from glob import glob # Remove existing files filenames = glob(join(p['figspath'], p['name'] + '_stim_onset_unit*')) for filename in filenames: os.remove(filename) print("Removed {}".format(filename)) # Load sorted trials sortedfile = get_sortedfile_stim_onset(p) with open(sortedfile) as f: t, sorted_trials = pickle.load(f) for i in xrange(p['model'].N): # Check if the unit does anything active = False for r in sorted_trials.values(): if is_active(r[i]): active = True break if not active: continue fig = Figure() plot = fig.add() #----------------------------------------------------------------------------- # Plot #----------------------------------------------------------------------------- plot_unit(i, sortedfile, plot) plot.xlabel('Time (ms)') plot.ylabel('Firing rate (a.u.)') props = { 'prop': { 'size': 8 }, 'handletextpad': 1.02, 'labelspacing': 0.6 } plot.legend(bbox_to_anchor=(0.18, 1), **props) #----------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name'] + '_stim_onset_unit{:03d}'.format(i)) fig.close() #------------------------------------------------------------------------------------- # Plot single-unit activity aligned to response #------------------------------------------------------------------------------------- elif action == 'units_response': from glob import glob # Remove existing files filenames = glob(join(p['figspath'], p['name'] + '_response_unit*')) for filename in filenames: os.remove(filename) print("Removed {}".format(filename)) # Load sorted trials sortedfile = get_sortedfile_response(p) with open(sortedfile) as f: t, sorted_trials = pickle.load(f) for i in xrange(p['model'].N): # Check if the unit does anything active = False for r in sorted_trials.values(): if is_active(r[i]): active = True break if not active: continue fig = Figure() plot = fig.add() #----------------------------------------------------------------------------- # Plot #----------------------------------------------------------------------------- plot_unit(i, sortedfile, plot) plot.xlabel('Time (ms)') plot.ylabel('Firing rate (a.u.)') props = { 'prop': { 'size': 8 }, 'handletextpad': 1.02, 'labelspacing': 0.6 } plot.legend(bbox_to_anchor=(0.18, 1), **props) #----------------------------------------------------------------------------- fig.save(path=p['figspath'], name=p['name'] + '_response_unit_{:03d}'.format(i)) fig.close() #------------------------------------------------------------------------------------- # Selectivity #------------------------------------------------------------------------------------- elif action == 'selectivity': # Model m = p['model'] trialsfile = get_trialsfile(p) dprime = get_choice_selectivity(trialsfile) def get_first(x, p): return x[:int(p * len(x))] psig = 0.25 units = np.arange(len(dprime)) try: idx = np.argsort(abs(dprime[m.EXC]))[::-1] exc = get_first(units[m.EXC][idx], psig) idx = np.argsort(abs(dprime[m.INH]))[::-1] inh = get_first(units[m.INH][idx], psig) idx = np.argsort(dprime[exc])[::-1] units_exc = list(exc[idx]) idx = np.argsort(dprime[inh])[::-1] units_inh = list(units[inh][idx]) units = units_exc + units_inh dprime = dprime[units] except AttributeError: idx = np.argsort(abs(dprime))[::-1] all = get_first(units[idx], psig) idx = np.argsort(dprime[all])[::-1] units = list(units[all][idx]) dprime = dprime[units] # Save d' filename = get_dprimefile(p) np.savetxt(filename, dprime) print("[ {}.do ] d\' saved to {}".format(THIS, filename)) # Save selectivity filename = get_selectivityfile(p) np.savetxt(filename, units, fmt='%d') print("[ {}.do ] Choice selectivity saved to {}".format( THIS, filename)) #------------------------------------------------------------------------------------- else: print("[ {}.do ] Unrecognized action.".format(THIS))
#------------------------------------------------------------------------------------- # Plot #------------------------------------------------------------------------------------- from pycog import RNN from pycog.figtools import Figure rng = np.random.RandomState(1066) rnn = RNN('workingMemory_savefile.pkl', {'dt': 2}) trial_args = {'name': 'test', 'catch': False, 'pair': (15, 30)} info = rnn.run(inputs=(generate_trial, trial_args), rng=rng) fig = Figure() plot = fig.add() epochs = info['epochs'] f1_start, f1_end = epochs['f1'] f2_start, f2_end = epochs['f2'] t0 = f1_start tmin = 0 tmax = f2_end t = 1e-3*(rnn.t-t0) delay = [1e-3*(f1_end-t0), 1e-3*(f2_start-t0)] yall = [] plot.plot(t, rnn.u[0], color=Figure.colors('orange'), lw=0.5) #plot.plot(t, rnn.u[1], color=Figure.colors('blue'), lw=0.5)
from pycog import tasktools from pycog import RNN from pycog.figtools import Figure m = imp.load_source('model', 'romo.py') rng = np.random.RandomState(1066) rnn = RNN('romo_savefile.pkl', {'dt': 2}) trial_args = {'name': 'test', 'catch': False, 'fpair': (34, 26), 'gt_lt': '>'} info = rnn.run(inputs=(m.generate_trial, trial_args), rng=rng) fig = Figure() plot = fig.add() epochs = info['epochs'] f1_start, f1_end = epochs['f1'] f2_start, f2_end = epochs['f2'] t0 = f1_start tmin = 0 tmax = f2_end t = 1e-3*(rnn.t-t0) delay = [1e-3*(f1_end-t0), 1e-3*(f2_start-t0)] yall = [] plot.plot(t, rnn.u[0], color=Figure.colors('orange'), lw=0.5) plot.plot(t, rnn.u[1], color=Figure.colors('blue'), lw=0.5)
betafile = join(base, 'examples', 'work', 'data', 'mante', 'mante_beta.pkl') units = [16, 17, 64, 74] #========================================================================================= # Figure setup #========================================================================================= w = 7.5 h = 6.7 r = w / h fig = Figure(w=w, h=h, axislabelsize=6.5, labelpadx=5, labelpady=5, thickness=0.6, ticksize=3, ticklabelsize=6, ticklabelpad=2, format=paper.format) #----------------------------------------------------------------------------------------- # Psychometric functions #----------------------------------------------------------------------------------------- w_psy = 0.16 dx_psy = w_psy + 0.07 x_psy = 0.08 h_psy = 0.15 dy_psy = h_psy + 0.07
n_validation = 100 if __name__ == '__main__': from pycog import RNN from pycog.figtools import Figure rnn = RNN('work/data/multi_sequence8mod/multi_sequence8mod.pkl', { 'dt': 0.5, 'var_rec': 0.01**2, 'var_in': np.array([0.003**2]) }) trial_args = {} info = rnn.run(inputs=(generate_trial, trial_args), seed=7423) fig = Figure() plot = fig.add() colors = [ 'red', 'green', 'yellow', 'orange', 'purple', 'cyan', 'magenta', 'pink' ] plot.plot(rnn.t / tau, rnn.u[0], color=Figure.colors('blue')) for i in range(Nout): plot.plot(rnn.t / tau, rnn.z[i], color=Figure.colors(colors[int(i / NoutSplit)])) Nexc = int(N * 0.8) plot.plot(rnn.t / tau, rnn.r[:Nexc].mean(axis=0),
import numpy as np from pycog.figtools import Figure w = 174/25.4 r = 0.6 h = r*w fig = Figure(w=w, h=h) w = 0.4 h = 0.18 x0 = 0.07 y0 = 0.72 dx = 1.23*w dy = 1.25*h plots = { 'SL-f': fig.add([x0, y0, w, h]), 'SL-s': fig.add([x0, y0-dy, w, h]), 'SL-e': fig.add([x0, y0-2*dy, w, h], 'none'), 'SL-o': fig.add([x0, y0-3*dy, w, h]), 'RL-f': fig.add([x0+dx, y0, w, h]), 'RL-s': fig.add([x0+dx, y0-dy, w, h]), 'RL-e': fig.add([x0+dx, y0-2*dy, w, h], 'none'), 'RL-o': fig.add([x0+dx, y0-3*dy, w, h], 'none') } x0 = 0.01 x1 = x0 + dx y0 = 0.95 plotlabels = { 'A': (x0, y0),