def full_analysis(args): DATA = get_dataset() VC, ECR, TAU2, TAU1, SEXT, DUR = [], [], [], [], [], [] for i in range(len(DATA)): try: X = np.load('../ring_model/data/fitted_data_' + str(i) + '.npy') for vec, VEC in zip(X, [VC, ECR, TAU2, TAU1, SEXT]): VEC.append(vec) DUR.append(DATA[i]['duration']) except IOError: pass fig, AX = plt.subplots(1, 4, figsize=(6., 2.3)) plt.subplots_adjust(bottom=.3, left=.25, wspace=3.) for ax, vec, label, ylim in zip( AX, [VC, ECR, np.array(ECR) / 5., SEXT], ['$v_c$ (mm/s)', '$l_{exc}$ (mm)', '$l_{inh}$ (mm)', '$s_{ext}$ (mm)'], [[0, 500], [0, 6], [0, 6], [0, 4]]): ax.plot([0, 0], ylim, 'w.', ms=0.1) ax.bar([0], [np.array(vec).mean()], yerr=[np.array(vec).std()], color='lightgray', edgecolor='k', lw=3) set_plot(ax, ['left'], xticks=[], ylabel=label) fig2, AX = plt.subplots(1, 2, figsize=(3.2, 2.3)) plt.subplots_adjust(bottom=.3, left=.3, wspace=1.8) AX[0].plot(DUR, 1e3 * np.array(TAU1), 'o') AX[0].plot(DUR, 1e3 * np.array(TAU2), 'o') plt.show()
def get_residual(args, new_time, space, new_data, Nsmooth=2, fn='../ring_model/data/example_data.npy', model_normalization_factor=None, with_plot=False): new_time, space,\ model_data_common_sampling,\ exp_data_common_sampling =\ reformat_model_data_for_comparison(fn, new_time, space, new_data, model_normalization_factor=model_normalization_factor, with_global_normalization=True) if with_plot: fig, AX = plt.subplots(2, figsize=(4.5, 5)) plt.subplots_adjust(bottom=.23, top=.97, right=.85, left=.3) plt.axes(AX[0]) c = AX[0].contourf(new_time, space, exp_data_common_sampling, np.linspace(exp_data_common_sampling.min(), exp_data_common_sampling.max(), args.Nlevels), cmap=cm.viridis) plt.colorbar(c, label='norm. VSD', ticks=.5 * np.arange(3)) set_plot(AX[0], xticks_labels=[], ylabel='space (mm)') plt.axes(AX[1]) # to have the zero at the same color level factor = np.abs(exp_data_common_sampling.min() / exp_data_common_sampling.max()) model_data_common_sampling[ -1, -1] = -factor * model_data_common_sampling.max() c2 = AX[1].contourf(new_time, space, model_data_common_sampling, np.linspace(model_data_common_sampling.min(), model_data_common_sampling.max(), args.Nlevels), cmap=cm.viridis) plt.colorbar(c2, label='norm. $\\delta V_N$', ticks=.5 * np.arange(3)) set_plot(AX[1], xlabel='time (ms)', ylabel='space (mm)') if args.save: fig.savefig('/Users/yzerlaut/Desktop/temp.svg') else: show() return np.sum((exp_data_common_sampling - model_data_common_sampling)**2)
def make_row_fig(cond, AX, with_top_label=False, fd=0): F1, Fe, Fi = data[col_key][cond], data[xkey][cond], data[ckey][cond] mFout, sFout = Fout_mean[cond], Fout_std[cond] for i, f1 in enumerate(np.unique(F1)[col_subsmpl]): i0 = np.argwhere(F1==f1).flatten() for j, fi in enumerate(np.unique(Fi[i0])): i1 = np.argwhere((Fi[i0]==fi)).flatten() cond2 = (mFout[i0][i1]>=ylim[0]) & (mFout[i0][i1]<ylim[1]) AX[i].errorbar(Fe[i0][i1][cond2], Fout_mean[i0][i1][cond2], yerr=Fout_std[i0][i1][cond2], fmt='o', ms=4, color=cmap(j/len(np.unique(Fi[i0])))) # # now analytical estimate if with_theory: RATES = {xkey:np.concatenate([np.linspace(f1, f2, th_discret, endpoint=False)\ for f1, f2 in zip(Fe[i0][i1][:-1], Fe[i0][i1][1:])])} for pop, f in zip([col_key, ckey, row_key],[f1, fi, fd]) : RATES[pop] = f*np.ones(len(RATES[xkey])) Fout_th = TF(RATES, data['Model'], data['Model']['NRN_KEY']) th_cond = (Fout_th>ylim[0]) & (Fout_th<ylim[1]) AX[i].plot(RATES[xkey][th_cond], Fout_th[th_cond], '-', color=cmap(j/len(np.unique(Fi[i0]))), lw=5, alpha=.7) if with_top_label: AX[i].set_title(col_key_label+'='+str(round(f1,1))+col_key_unit) if logscale: AX[i].set_yscale('log') AX[i].set_xscale('log') ylabel2, yticks_labels2 = '', [] if i==0: # if first column ylabel2, yticks_labels2 = ylabel, yticks_labels set_plot(AX[i], ylim=[.9*ylim[0], ylim[1]], yticks=yticks, xticks=xticks, ylabel=ylabel2, xlabel=xlabel, yticks_labels=yticks_labels2, xticks_labels=xticks_labels) Fi_log = np.log(Fi)/np.log(10) cax = inset_axes(AX[-1], width="20%", height="90%", loc=3) Fi_ticks, Fi_ticks_labels = [], [] for k in np.arange(-2, 3): for l in range(1, 10): Fi_ticks.append(np.log(l)/np.log(10) +k) if l%10==1: Fi_ticks_labels.append(str(l*np.exp(k*np.log(10)))) else: Fi_ticks_labels.append('') # Fi_ticks, Fi_ticks_labels = np.arange(-2,2), ['0.01','0.1','1', '10'] cb = build_bar_legend(Fi_ticks, cax , cmap, bounds = [np.log(Fi.min())/np.log(10), np.log(Fi.max())/np.log(10)], ticks_labels=Fi_ticks_labels, color_discretization=100, label=ckey_label) AX[-1].axis('off')
def make_second_fig(): DISTANCE, ERROR = find_minimum_with_distance() bins = np.logspace(np.log(ERROR.min())/np.log(10),np.log(ERROR.max())/np.log(10),10) hist, be = np.histogram(ERROR, bins=bins) from graphs.my_graph import set_plot fig, AX = plt.subplots(1, figsize=(5,4)) plt.subplots_adjust(bottom=.3, left=.2) AX.bar(be[:-1], hist, width=np.diff(bins), edgecolor='k', color='lightgray', lw=2) AX.set_xscale('log') set_plot(AX, xticks=np.logspace(-2,1,4), xlabel='goodness to fit', ylabel='morphology number') return fig
def plot_response(args): fig, ax = plt.subplots(1, figsize=(4.7, 3)) fig.suptitle(get_dataset()[args.data_index]['filename']) plt.subplots_adjust(bottom=.23, top=.9, right=.84, left=.25) print(get_dataset()[args.data_index]) f = loadmat(get_dataset()[args.data_index]['filename']) data = 1e3 * f['matNL'][0]['stim1'][0] time = f['matNL'][0]['time'][0].flatten() + args.tshift print(time[-1] - time[0]) space = f['matNL'][0]['space'][0].flatten() if args.Nsmooth > 0: smoothing = np.ones((args.Nsmooth, args.Nsmooth)) / args.Nsmooth**2 smooth_data = convolve2d(data, smoothing, mode='same') else: smooth_data = data cond = (time > args.t0) & (time < args.t1) c = ax.contourf(time[cond], space, smooth_data[:,cond],\ np.linspace(smooth_data.min(), smooth_data.max(), args.Nlevels), cmap=cm.viridis) plt.colorbar(c, label='VSD signal ($\perthousand$)', ticks=args.vsd_ticks) x1, x2 = ax.get_xlim() ax.plot([x1, x1], [0, 2], '-', color='gray', lw=4) ax.annotate('2mm', (x1, 2), rotation=90, fontsize=14) y1, y2 = ax.get_ylim() ax.plot([x1, x1 + 50], [y1, y1], '-', color='gray', lw=4) ax.annotate('50ms', (x1 + 20, y1 + .5), fontsize=14) if args.with_onset_propag: tt, xx = find_latencies_over_space_simple(time, space, smooth_data[:,cond], signal_criteria=args.signal_criteria,\ amp_criteria=args.amp_criteria) plt.plot(tt + args.tshift, xx, 'o', lw=0, ms=1, color='k') # for intervals in [[0,2.3], [2.5,5.7], [5.9,8.5]]: # cond = (xx>intervals[0]) & (xx<intervals[1]) & (tt<20) # pol = np.polyfit(xx[cond], tt[cond]+100, 1) # xxx = np.linspace(xx[cond][0], xx[cond][-1]) # plt.plot(np.polyval(pol, xxx), xxx, 'w--', lw=2) # set_plot(ax, ['bottom'], yticks=[], xlabel='time (ms)') set_plot(ax, xlabel='time (ms)', ylabel='space (mm)') if args.SAVE: fig.savefig('/Users/yzerlaut/Desktop/temp.svg') else: show()
def fig_with_average_trace(t_window, TEST_TRACES, CTRL_TRACES, delay, duration,\ threshold=-30, color='r'): # then fig with averages fig, ax = plt.subplots(1, figsize=(5, 3.5)) ax.set_title('delay='+str(delay)+'ms, duration='+str(duration)+'ms, n='+\ str(len(TEST_TRACES))+' trials',fontsize=12) plt.subplots_adjust(left=.2, bottom=.25) CTRL_TRACES = np.array(CTRL_TRACES) CTRL_TRACES[CTRL_TRACES > threshold] = threshold TEST_TRACES = np.array(TEST_TRACES) TEST_TRACES[TEST_TRACES > threshold] = threshold ax.plot(t_window, CTRL_TRACES.mean(axis=0), 'k', lw=2, label='blank trials') ax.fill_between(t_window,\ CTRL_TRACES.mean(axis=0)-CTRL_TRACES.std(axis=0),\ CTRL_TRACES.mean(axis=0)+CTRL_TRACES.std(axis=0), color='lightgray') ax.plot(t_window,\ CTRL_TRACES.mean(axis=0)-CTRL_TRACES.std(axis=0),\ color='k', lw=.5) ax.plot(t_window,\ CTRL_TRACES.mean(axis=0)+CTRL_TRACES.std(axis=0), color='k', lw=.5) ax.plot(t_window, TEST_TRACES.mean(axis=0), color, lw=2, label='test trials') ax.plot(t_window,\ TEST_TRACES.mean(axis=0)+TEST_TRACES.std(axis=0), color=color, lw=.5) ax.plot(t_window,\ TEST_TRACES.mean(axis=0)-TEST_TRACES.std(axis=0),\ color=color, lw=.5) ax.fill_between(t_window,\ TEST_TRACES.mean(axis=0)-TEST_TRACES.std(axis=0),\ TEST_TRACES.mean(axis=0)+TEST_TRACES.std(axis=0), color=color, alpha=.3) ax.legend(prop={'size': 'small'}, loc='best', frameon=False) set_plot(ax, ylabel='$V_m$ (mV)', xlabel='delay from state onset (ms)') ax.fill_between([delay, delay+duration],\ ax.get_ylim()[0]*np.ones(2), ax.get_ylim()[1]*np.ones(2),\ color=color, alpha=.2) return fig
def make_experimental_fig(index): fig, AX = plt.subplots(1, 2, figsize=(11,4)) plt.subplots_adjust(bottom=.2) all_freq, all_psd, all_phase = np.load('full_data.npy') mymap = get_linear_colormap() X = 300+np.arange(3)*300 HIGH_BOUND = 450 # higher nound for frequency f_bins = np.logspace(np.log(.1)/np.log(10), np.log(HIGH_BOUND)/np.log(10), 20) digitized = np.digitize(all_freq, f_bins) psd_means = np.array([all_psd[digitized == i].mean() for i in range(1, len(f_bins))]) psd_std = np.array([all_psd[digitized == i].std() for i in range(1, len(f_bins))]) phase_means = np.array([all_phase[digitized == i].mean() for i in range(1, len(f_bins))]) phase_std = np.array([all_phase[digitized == i].std() for i in range(1, len(f_bins))]) AX[0].errorbar(.5*(f_bins[1:]+f_bins[:-1]), psd_means, yerr=psd_std, color='gray', lw=3, label='data') AX[0].fill_between(.5*(f_bins[1:]+f_bins[:-1]), psd_means-psd_std, psd_means+psd_std, color='lightgray') AX[1].errorbar(.5*(f_bins[1:]+f_bins[:-1]), phase_means, yerr=phase_std, color='gray', lw=3, label='data') AX[1].fill_between(.5*(f_bins[1:]+f_bins[:-1]), phase_means-phase_std, phase_means+phase_std, color='lightgray') ### MEAN MODEL j=0 for b, ls, ld, dd, g_pas, cm, ra in itertools.product(B, L_soma, L_dend, D_dend, G_PAS, CM, RA): if j==index: soma1, stick1, params1 = soma.copy(), stick.copy(), params.copy() soma1['L'] = ls stick1['B'], stick1['D'], stick1['L'] = b, dd, ld params1['g_pas'], params1['cm'], params1['Ra'] = g_pas, cm, ra psd, phase = get_input_imped(soma1, stick1, params1) fig.suptitle('B='+str(b)+', Ls='+str(1e6*ls)+'um, Ld='+str(1e6*ld)+'um, Dd='+\ str(1e6*dd)+'um, Gl='+str(1e2*g_pas)+'uS/cm2, Cm='+str(1e2*cm)+'uF/cm2, Ri='+str(1e2*ra)+'Ohm.m') j+=1 AX[0].loglog(f, psd, 'k-', alpha=.8, lw=4) AX[1].semilogx(f, phase, 'k-', alpha=.8, lw=4, label='medium size \n model') set_plot(AX[0], xlim=[.08,1000],\ xticks=[1,10,100,1000], yticks=[10,100,1000],yticks_labels=['10','100','1000'],\ xlabel='frequency (Hz)',ylabel='modulus ($\mathrm{M}\Omega$)') set_plot(AX[1], xlim=[.08,1000], ylim=[-.2,2.3],\ xticks=[1,10,100,1000], yticks=[0,np.pi/4.,np.pi/2.],\ yticks_labels=[0,'$\pi/4$', '$\pi/2$'], xlabel='frequency (Hz)', ylabel='phase shift (Rd)') return fig
def RASTER_PLOT(SPK_LIST, ID_LIST, tlim=None, ID_ZOOM_LIST=None, COLORS=None, with_fig=None, MS=1): if with_fig is not None: fig, ax = plt.gcf(), plt.gca() else: fig, ax = plt.subplots(1, figsize=(5, 3)) plt.subplots_adjust(left=.25, bottom=.25) # time limit if tlim is None: tlim = np.ones(2) tlim[0] = np.min([np.min(spk) for spk in SPK_LIST]) tlim[1] = np.max([np.max(spk) for spk in SPK_LIST]) # neurons limit if ID_ZOOM_LIST is None: ID_ZOOM_LIST = [] for ids in ID_LIST: ID_ZOOM_LIST.append([np.min(ids), np.max(ids)]) # colors if COLORS is None: COLORS = ['g'] + ['r'] + ['k' for i in range(len(ID_LIST) - 2)] ii = 0 # index for plotting for spks, ids, id_zoom, col in zip(SPK_LIST, ID_LIST, ID_ZOOM_LIST, COLORS): spks2, ids2 = spks[(spks >= tlim[0]) & (spks <= tlim[1]) & (ids >= id_zoom[0]) & (ids <= id_zoom[1])], ids[(spks >= tlim[0]) & (spks <= tlim[1]) & (ids >= id_zoom[0]) & (ids <= id_zoom[1])] plt.plot(spks2, ii + ids2, '.', color=col, ms=MS) ii += id_zoom[1] - id_zoom[0] tot_neurons_num = int( round(np.sum([(I[1] - I[0]) for I in ID_ZOOM_LIST]) / 100., 0) * 100) ax.set_title(str(tot_neurons_num) + ' neurons sample', fontsize=14) my_graph.set_plot(ax, xlabel='time (ms)', yticks=[], ylabel='neuron index') return fig, ax
def plot_VC_episodes(main): t, VEC = BIN_load(main.filename, zoom=[main.args['x1'], main.args['x2']]) y1, y2 = main.args['y1_min'], main.args['y1_max'] fig = plt.figure(figsize=(10, 7)) plt.subplots_adjust(left=.15, bottom=.15, top=.96, right=.96) ax = plt.subplot2grid((3, 1), (0, 0), rowspan=2) mymap = get_linear_colormap(color1='blue', color2='red') for i in range(VEC.shape[1]): ax.plot(1e3*t, VEC[0][i], '-',\ color=mymap(np.linspace(0,1,VEC.shape[1])[i],1)) set_plot(ax, ['left'], ylabel='$I_{amp}$ (pA)',\ xlim=[main.args['x1'], main.args['x2']], xticks=[],\ ylim=[y1, y2]) ax2 = plt.subplot2grid((3, 1), (2, 0)) for i in range(VEC.shape[1]): ax2.plot(1e3*t, VEC[1][i], '-', alpha=.5,\ color=mymap(np.linspace(0,1,VEC.shape[1])[i],1)) set_plot(ax2, xlabel='time (ms)', ylabel='$V_A$ (mV)',\ xlim=[main.args['x1'], main.args['x2']]) return [fig]
def fig_with_sample_traces(t_window, TEST_TRACES, CTRL_TRACES, delay, duration,\ threshold=-30, color='r', N=10): # then fig with all traces fig, ax = plt.subplots(1, figsize=(5, 3.5)) ax.set_title('delay='+str(delay)+'ms, duration='+str(duration)+'ms, n='+\ str(len(TEST_TRACES))+' trials',fontsize=12) plt.subplots_adjust(left=.2, bottom=.25) for v in CTRL_TRACES[:N]: ax.plot(t_window, v, 'k', lw=.5) ax.plot(t_window, CTRL_TRACES[-1], 'k',\ label='blank trials', lw=.5) for v in TEST_TRACES[:N]: plt.plot(t_window, v, color, lw=.5) ax.plot(t_window, TEST_TRACES[-1], color,\ label='test trials', lw=.5) ax.legend(prop={'size': 'x-small'}, loc='best', frameon=False) set_plot(ax, ylabel='$V_m$ (mV)', xlabel='delay from state onset (ms)') ax.fill_between([delay, delay+duration],\ ax.get_ylim()[0]*np.ones(2), ax.get_ylim()[1]*np.ones(2),\ color=color, alpha=.2) return fig
def make_first_fig(): DISTANCE, ERROR = find_minimum_with_distance() N = 40 bins_positive = np.logspace(-9,np.log(DISTANCE.max())/np.log(10),N) bins_negative = np.logspace(-9,np.log(-DISTANCE.min())/np.log(10),N) i_positive = np.digitize(DISTANCE[DISTANCE>0], bins_positive) i_negative = np.digitize(-DISTANCE[DISTANCE<0], bins_negative) x_plus, val_plus, val_min = [], [], [] x_min, val_plus_std, val_min_std = [], [], [] for i in range(N): if len(ERROR[DISTANCE>0][i_positive==i])>0: val_plus.append(np.mean(ERROR[DISTANCE>0][i_positive==i])) val_plus_std.append(np.std(ERROR[DISTANCE>0][i_positive==i])) x_plus.append(bins_positive[i]) if len(ERROR[DISTANCE>0][i_positive==i])>0: val_min.append(np.mean(ERROR[DISTANCE<0][i_negative==i])) val_min_std.append(np.std(ERROR[DISTANCE<0][i_negative==i])) x_min.append(bins_negative[i]) sys.path.append('../../') from graphs.my_graph import set_plot fig, AX = plt.subplots(1,2, figsize=(10,4)) AX[1].plot([DISTANCE[DISTANCE>0].min(),DISTANCE.max()],\ [ERROR.min(),ERROR.min()], '-', color='lightgray', lw=5) AX[1].plot(DISTANCE[DISTANCE>0], ERROR[DISTANCE>0], 'k.', alpha=.05) AX[1].errorbar(x_plus, val_plus, yerr=val_plus_std, color='k', lw=3) AX[1].set_xscale('log');AX[1].set_yscale('log') set_plot(AX[1], yticks=np.logspace(-2,0,3), xticks=np.logspace(-2,0,3), ylabel='error (log)') AX[0].plot([DISTANCE[DISTANCE>0].min(),DISTANCE.max()],\ [ERROR.min(),ERROR.min()], '-', color='lightgray', lw=5) AX[0].plot(-DISTANCE[DISTANCE<0], ERROR[DISTANCE<0], 'k.', alpha=.05) AX[0].errorbar(x_min, val_min, yerr=val_min_std, color='k', lw=3) AX[0].set_xscale('log');AX[0].set_yscale('log') set_plot(AX[0], yticks=np.logspace(-2,0,3), xticks=np.logspace(-2,0,3), ylabel='error (log)') return fig
def default_plot(main, xlabel='time (s)', ylabel=''): Nchannels = min([main.params['Nchannels'], 4]) # max 4 channels displayed fig, AX = plt.subplots(Nchannels, figsize=(30.,6.*Nchannels)) plt.subplots_adjust(left=.15, bottom=.2, hspace=0.2, right=.95, top=.99) key_list = list(main.data.keys()) key_list.remove("t") try: key_list.remove("params") except ValueError: pass cond = (main.data['t']>main.args['x1']) & (main.data['t']<=main.args['x2']) for i, key in enumerate(sorted(key_list)[:Nchannels]): AX[i].plot(main.data['t'][cond], main.data[key][cond]) if i==Nchannels-1: set_plot(AX[i], xlabel=xlabel, ylabel=key, num_yticks=3) else: set_plot(AX[i], ['left'], ylabel=key, num_yticks=3, xticks=[]) return fig
def fig_with_current_pulse_analysis(t_window, TEST_TRACES, CTRL_TRACES,\ delay, duration, params,\ threshold=-30, color='k'): CTRL_TRACES = np.array(CTRL_TRACES) CTRL_TRACES[CTRL_TRACES > threshold] = threshold # then fig with all traces fig, ax = plt.subplots(1, figsize=(6.5, 4.5)) ax.set_title('n=' + str(len(CTRL_TRACES)) + ' trials', fontsize=12) plt.subplots_adjust(left=.2, bottom=.25) for v in CTRL_TRACES: plt.plot(t_window, v, color, lw=.2) ax.legend(prop={'size': 'x-small'}, loc='best', frameon=False) ax.plot(t_window, CTRL_TRACES.mean(axis=0), 'k', lw=2, label='blank trials') ax.fill_between(t_window,\ CTRL_TRACES.mean(axis=0)-CTRL_TRACES.std(axis=0),\ CTRL_TRACES.mean(axis=0)+CTRL_TRACES.std(axis=0), color='lightgray') ax.plot(t_window,\ CTRL_TRACES.mean(axis=0)-CTRL_TRACES.std(axis=0),\ color='k', lw=.5) ax.plot(t_window,\ CTRL_TRACES.mean(axis=0)+CTRL_TRACES.std(axis=0), color='k', lw=.5) ## now fitting tcond = (t_window > float(params['CMD_delay']) - 10.) & ( t_window < float(params['CMD_delay']) + float(params['CMD_dur'])) El, Tm, Gl, func = fit_membrane_prop(t_window[tcond],\ CTRL_TRACES.mean(axis=0)[tcond], params) ax.plot(t_window[tcond], func(t_window[tcond], El, Tm, Gl), 'r:', lw=3) ax.annotate('$V_0$='+str(np.round(El))+'mV, $\\tau_m$='+str(np.round(Tm))+\ 'ms, $g_L$='+str(np.round(Gl))+'nS', (0.1,.86), xycoords='axes fraction') set_plot(ax, ylabel='$V_m$ (mV)', xlabel='delay from state onset (ms)') return [fig]
def __init__(self, data, dx, xlim, x_bar, x_units): self.addedData = [] print(matplotlib.__version__) y0, y1 = data.min(), data.max() # The data self.xlim = min([len(data), int(xlim / dx)]) self.n = np.linspace(0, self.xlim - 1, self.xlim) self.y = (self.n * 0.0) + data.mean() # The window self.fig = Figure(figsize=(5, 5), dpi=100) self.fig.subplots_adjust(bottom=.05, left=.1) self.ax1 = self.fig.add_subplot(111) # self.ax1 settings bar_lim = min([int(x_bar / dx), int(3. * self.xlim / 5)]) self.xbar = self.ax1.plot([int(self.xlim/5), bar_lim+int(self.xlim/5)],\ np.ones(2)*(y0+.1*(y1-y0)), 'k-', lw=5) self.ax1.plot([0, self.xlim - 1], [y0, y1], 'w.', ms=1e-4) self.xbar_legend = self.ax1.annotate(str(int(x_bar))+x_units,\ (int(self.xlim/5),y0)) self.line1 = Line2D([], [], color='blue') self.line1_tail = Line2D([], [], color='red', linewidth=2) self.line1_head = Line2D([], [], color='red', marker='o', markeredgecolor='r') self.ax1.add_line(self.line1) self.ax1.add_line(self.line1_tail) self.ax1.add_line(self.line1_head) set_plot(self.ax1, ['left'], xlim=[0, self.xlim - 1], xticks=[]) FigureCanvas.__init__(self, self.fig) TimedAnimation.__init__(self, self.fig, interval=50, blit=True)
def POP_ACT_PLOT(t, POP_ACT_LIST, tlim=None, pop_act_zoom=None, COLORS=None, with_fig=None): if with_fig is not None: fig, ax = plt.gcf(), plt.gca() else: fig, ax = plt.subplots(1, figsize=(5, 3)) plt.subplots_adjust(left=.25, bottom=.25) # time limit if tlim is None: tlim = [t.min(), t.max()] # pop act lim if pop_act_zoom is None: pop_act_zoom = np.zeros(2) pop_act_zoom[0] = np.min([np.min(act) for act in POP_ACT_LIST]) pop_act_zoom[1] = np.max([np.max(act) for act in POP_ACT_LIST]) ID_ZOOM_LIST = [] # colors if COLORS is None: COLORS = ['g'] + ['r'] + ['k' for i in range(len(POP_ACT_LIST) - 2)] for act, col in zip(POP_ACT_LIST[::-1], COLORS[::-1]): plt.plot(t[(t >= tlim[0]) & (t <= tlim[1])], act[(t >= tlim[0]) & (t <= tlim[1])], '-', color=col) my_graph.set_plot(ax, xlabel='time (ms)', ylabel='pop. act. (Hz)', ylim=pop_act_zoom) return fig, ax
def make_conversion_fig(Rm0=None): # we plot here the conversion between input resistance # and dendritic tree properties Rm_exp = get_Rm_range()[kept_cells] Rm = np.linspace(0.9 * Rm_exp.min(), 1.2 * Rm_exp.max(), 20) LS, LD, DD = 0 * Rm, 0 * Rm, 0 * Rm for i in range(len(Rm)): soma1, stick1, params1 = adjust_model_prop(Rm[i], soma, stick,\ precision=.01, maxiter=1e5) LS[i] = 1e6 * soma1['L'] DD[i], LD[i] = 1e6 * stick1['D'], 1e6 * stick1['L'] fig, AX = plt.subplots(4, figsize=(4.5, 8)) plt.subplots_adjust(left=.4, bottom=.15, hspace=.3) AX[0].set_title('resizing rule') AX[0].hist(Rm_exp, bins=np.linspace(Rm.min(), Rm.max(), 10),\ color='lightgray', edgecolor='k', lw=2) set_plot(AX[0], ['left'], ylabel='cell #', xticks=[]) for ax, y, label in zip(AX[1:3], [LS, DD],\ ['length of \n soma ($\mu$m)', 'root branch \n diameter ($\mu$m)']): ax.plot(Rm, y, 'k-', lw=2) set_plot(ax, ['left'], ylabel=label, xticks=[]) AX[3].plot(Rm, LD, 'k-', lw=2) set_plot(AX[3], ylabel='tree length \n ($\mu$m)',\ xlabel='somatic input \n resistance (M$\Omega$)',\ xticks=[200,400,600]) soma0, stick0, params0 = adjust_model_prop(Rm_exp.mean(),\ soma, stick, precision=.1, maxiter=1e4) if Rm0 is not None: AX[1].plot([Rm_exp.mean()], [1e6 * soma0['L']], 'kD') AX[2].plot([Rm_exp.mean()], [1e6 * stick0['D']], 'kD') AX[3].plot([Rm_exp.mean()], [1e6 * stick0['L']], 'kD') return fig
fig.suptitle('$f_{prox}$ = ' + str(new_ratio) + '%') for i in range(len(PROTOCOLS)): feG, fiG, feI, fiI, synch, muV, sV, TvN, muGn = get_fluct_var(i_nrn,\ exp_type=PROTOCOLS[i], len_f=len_f, precision=precision) for ax, x in zip(AX, [1e3 * muV, 1e3 * sV, 1e2 * TvN, muGn]): ax.plot(F, x, lw=4, color=COLORS[i], label=PROTOCOLS[i]) for ax, x in zip(AX2, [feG, fiG, feI, fiI, synch]): ax.plot(F, x, lw=4, color=COLORS[i], label=PROTOCOLS[i]) plt.show(block=False) input('Hit Enter To Close') plt.close() if sys.argv[-1] != 'all': from graphs.my_graph import set_plot for ax, ylabel in zip(AX[:-1], LABELS[:-1]): set_plot(ax, ['left'], ylabel=ylabel, xticks=[], num_yticks=4) for ax, ylabel in zip(AX2[:-1], LABELS2[:-1]): set_plot(ax, ['left'], ylabel=ylabel, xticks=[], num_yticks=4) set_plot(AX[-2], ['left'], ylabel=LABELS[-2], xticks=[], num_yticks=4) set_plot(AX[-1], ['bottom','left'],\ ylabel=LABELS[-1], xticks=[], xlabel='increasing \n presynaptic quantity') set_plot(AX2[-2], ['left'], ylabel=LABELS2[-2], xticks=[], num_yticks=4) #, yticks=[0,1,2]) set_plot(AX2[1], ['left'], ylabel=LABELS2[1], xticks=[], num_yticks=4) #, yticks=[0,2,4]) set_plot(AX2[0], ['left'], ylabel=LABELS2[0], xticks=[], num_yticks=4) #, yticks=[0,0.3,0.6]) set_plot(AX2[2], ['left'], ylabel=LABELS2[2], xticks=[], num_yticks=4) #, yticks=[0,0.15,0.3])
def full_plot(args): DATA = get_dataset() VC, SE, ECR, ICR, TAU2, TAU1, DUR, MONKEY = [], [], [], [], [], [], [], [] for i in range(len(DATA)): args.data_index = i params = get_minimum_params(args) for vec, VEC in zip(params, [VC, SE, ECR, ICR, TAU2, TAU1]): VEC.append(vec) DUR.append(DATA[i]['duration']) MONKEY.append(DATA[i]['Monkey']) # vc fig1, ax1 = plt.subplots(1, figsize=(1.5, 2.3)) plt.subplots_adjust(bottom=.4, left=.6) ax1.fill_between([-1., 1.], np.ones(2) * args.vc[0], np.ones(2) * args.vc[1], color='lightgray', alpha=.8, label=r'$\mathcal{D}$ domain') ax1.bar([0], [np.array(VC).mean()], yerr=[np.array(VC).std()], color='lightgray', edgecolor='k', lw=3) ax1.legend(frameon=False) print('Vc = ', round(np.array(VC).mean()), '+/-', round(np.array(VC).std()), 'mm/s') set_plot(ax1, ['left'], xticks=[], ylabel='$v_c$ (mm/s)') # connectivity fig2, ax2 = plt.subplots(1, figsize=(2., 2.3)) plt.subplots_adjust(bottom=.4, left=.6) ax2.bar([0], [np.array(ECR).mean()], yerr=[np.array(ECR).std()], color='lightgray', edgecolor='g', lw=3, label='$l_{exc}$') print('Ecr=', round(np.array(ECR).mean(), 1), '+/-', round(np.array(ECR).std(), 1), 'mm/s') ax2.bar([1.5], [np.array(ICR).mean()], yerr=[np.array(ICR).std()], color='lightgray', edgecolor='r', lw=3, label='$l_{inh}$') print('Icr=', round(np.array(ICR).mean(), 1), '+/-', round(np.array(ICR).std(), 1), 'mm/s') ax2.fill_between([-1., 2.5], np.ones(2) * args.Econn_radius[0], np.ones(2) * args.Econn_radius[1], color='lightgray', alpha=.8) ax2.legend(frameon=False) ax2.annotate("p=%.1e" % ttest_rel(ECR, ICR).pvalue, (0.1, .1), xycoords='figure fraction') set_plot(ax2, ['left'], xticks=[], ylabel='extent (mm)') # stim extent fig3, ax3 = plt.subplots(1, figsize=(1.5, 2.3)) plt.subplots_adjust(bottom=.4, left=.6) ax3.bar([0], [np.array(SE).mean()], yerr=[np.array(SE).std()], color='lightgray', edgecolor='k', lw=3) print('Ecr=', round(np.array(SE).mean(), 1), '+/-', round(np.array(SE).std(), 1), 'mm/s') ax3.fill_between([-1., 1.], np.ones(2) * args.stim_extent[0], np.ones(2) * args.stim_extent[1], color='lightgray', alpha=.8) set_plot(ax3, ['left'], xticks=[], ylabel='$l_{stim}$ (mm)', yticks=[0, 1, 2]) DUR, TAU1, TAU2 = np.array(DUR), 1e3 * np.array(TAU1), 1e3 * np.array(TAU2) fig4, ax4 = plt.subplots(1, figsize=(2.5, 2.3)) plt.subplots_adjust(bottom=.4, left=.6) for d in np.unique(DUR): ax4.errorbar([d], [TAU1[DUR == d].mean()], yerr=[TAU1[DUR == d].std()], marker='o', color='k') ax4.plot([DUR.min(), DUR.max()], np.polyval(np.polyfit(DUR, TAU1, 1), [DUR.min(), DUR.max()]), 'k--', lw=0.5) ax4.fill_between([DUR.min(), DUR.max()], 1e3 * np.ones(2) * args.Tau1[0], 1e3 * np.ones(2) * args.Tau1[1], color='lightgray', alpha=.8) ax4.annotate("c=%.1e" % pearsonr(DUR, TAU1)[0], (0.1, .2), xycoords='figure fraction') ax4.annotate("p=%.1e" % pearsonr(DUR, TAU1)[1], (0.1, .1), xycoords='figure fraction') set_plot(ax4, xticks=[10, 50, 100], xlabel='$T_{stim}$ (ms)', ylabel='$\\tau_1$ (ms)', yticks=[0, 25, 50]) fig5, ax5 = plt.subplots(1, figsize=(2.5, 2.3)) plt.subplots_adjust(bottom=.4, left=.6) for d in np.unique(DUR): ax5.errorbar([d], [TAU2[DUR == d].mean()], yerr=[TAU2[DUR == d].std()], marker='o', color='k') ax5.plot([DUR.min(), DUR.max()], np.polyval(np.polyfit(DUR, TAU2, 1), [DUR.min(), DUR.max()]), 'k--', lw=0.5) ax5.fill_between([DUR.min(), DUR.max()], 1e3 * np.ones(2) * args.Tau2[0], 1e3 * np.ones(2) * args.Tau2[1], color='lightgray', alpha=.8) ax5.annotate("c=%.1e" % pearsonr(DUR, TAU2)[0], (0.1, .2), xycoords='figure fraction') ax5.annotate("p=%.1e" % pearsonr(DUR, TAU2)[1], (0.1, .1), xycoords='figure fraction') set_plot(ax5, xticks=[10, 50, 100], xlabel='$T_{stim}$ (ms)', ylabel='$\\tau_2$ (ms)', yticks=[40, 120, 200]) put_list_of_figs_to_svg_fig([fig1, fig2, fig3, fig4, fig5], fig_name="/Users/yzerlaut/Desktop/temp.svg") show()
def plot_analysis(args): Residuals,\ vcFull, seFull, ecrFull, icrFull,\ t2Full, t1Full = np.load(\ '../ring_model/data/residuals_data_'+str(args.data_index)+'.npy') i0 = np.argmin(Residuals) Residuals /= Residuals[i0] # normalizing fig, AX = plt.subplots(1, 6, figsize=(9, 2.)) plt.subplots_adjust(bottom=.3, left=.15) for ax, vec, label in zip(AX, [vcFull, seFull, ecrFull, icrFull, t2Full, t1Full],\ ['$v_c (mm/s)$','$l_{stim}$ (mm)', '$l_{exc}$ (mm)', '$l_{inh}$ (mm)', '$\\tau_2$ (ms)', '$\\tau_1$ (ms)']): ax.plot(vec, Residuals, 'o') ax.plot([vec[i0]], [Residuals[i0]], 'ro') ax.set_yscale('log') if ax == AX[0]: set_plot(ax, xlabel=label, ylabel='Residual (norm.)', yticks=[1, 2, 5, 10, 20], yticks_labels=['1', '2', '5', '10', '20']) else: set_plot(ax, xlabel=label, yticks=[1, 5, 10, 20], yticks_labels=[]) new_time, space, new_data = get_data(args.data_index, Nsmooth=args.Nsmooth, t0=args.t0, t1=args.t1) if args.force: fn = '../ring_model/data/model_data_' + str(args.data_index) + '.npy' t, X, Fe_aff, Fe, Fi, muVn =\ Euler_method_for_ring_model(\ 'RS-cell', 'FS-cell',\ 'CONFIG1', 'RING1', 'CENTER',\ custom_ring_params={\ 'X_discretization':args.X_discretization, 'X_extent':args.X_extent, 'conduction_velocity_mm_s':vcFull[i0], 'exc_connect_extent':ecrFull[i0], 'inh_connect_extent':icrFull[i0]}, custom_stim_params={\ 'sX':seFull[i0], 'amp':15., 'Tau1':t1Full[i0], 'Tau2':t2Full[i0]}) np.save(fn, [args, t, X, Fe_aff, Fe, Fi, muVn]) else: _, _, _, _, _, _, FILENAMES = np.load( '../ring_model/data/scan_data.npy') fn = FILENAMES[i0] res = get_residual(args, new_time, space, new_data, Nsmooth=args.Nsmooth, fn=fn, with_plot=True) show()
Rm_data = np.zeros(len(CELLS)) fig, ax = plt.subplots(figsize=(4, 3)) plt.subplots_adjust(bottom=.3, left=.3) if sys.argv[-1] == 'all': for i in range(len(CELLS))[::5]: Rm_data[i] = 1e-6 / CELLS[i]['Gl'] soma1, stick1, params1 = adjust_model_prop(Rm_data[i], soma, stick) Rtf_model, N_synapses = get_the_transfer_resistance_to_soma(soma1,\ stick1, params1) ax.hist(1e-6 * Rtf_model, label='cell' + str(i)) ax.legend(frameon=False, prop={'size': 'x-small'}, loc='best') set_plot(ax, xlabel='transfer resistance \n to soma $(M \Omega)$',\ ylabel='synapses #') else: for freq in [0., 2., 10.]: TF_model, Area = get_the_transfer_resistance_to_soma(soma, stick, params, precision=1000, with_area=True, freq=freq) edges, bins = np.histogram(1e-6 * TF_model, bins=30, weights=Area, normed=True) bins = .5 * (bins[:-1] + bins[1:]) plt.bar(bins, edges / edges.max(),
def make_experimental_fig(): fig, AX = plt.subplots(2, 2, figsize=(11, 8)) MICE, RATS = [], [] psd_boundaries = [200, 900] all_freq, all_psd, all_phase = [np.empty(0, dtype=float) for i in range(3)] HIGH_BOUND = 450 # higher nound for frequency for file in os.listdir("./intracellular_data/"): if file.endswith("_rat.txt"): _ = 0 elif file.endswith(".txt"): freq, psd, phase = np.loadtxt("./intracellular_data/" + file, unpack=True) MICE.append({ 'freq': freq[np.argsort(freq)], 'psd': psd[np.argsort(freq)], 'phase': (phase[np.argsort(freq)] % (2. * np.pi) + np.pi / 2.) % (2. * np.pi) - np.pi / 2. }) # print file, MICE[-1]['phase'].max() all_freq = np.concatenate([all_freq, MICE[-1]['freq']]) all_psd = np.concatenate([all_psd, MICE[-1]['psd']]) all_phase = np.concatenate([all_phase, MICE[-1]['phase']]) psd_boundaries[0] = min([psd_boundaries[0], psd.max()]) psd_boundaries[1] = max([psd_boundaries[1], psd.max()]) np.save('full_data.npy',\ [all_freq[all_freq<HIGH_BOUND], all_psd[all_freq<HIGH_BOUND], all_phase[all_freq<HIGH_BOUND]]) all_freq, all_psd, all_phase = np.load('full_data.npy') mymap = get_linear_colormap() X = 300 + np.arange(3) * 300 for m in MICE: rm = m['psd'][:3].mean() r = (rm - psd_boundaries[0]) / (psd_boundaries[1] - psd_boundaries[0]) AX[0, 0].loglog(m['freq'][m['freq'] < HIGH_BOUND], m['psd'][m['freq'] < HIGH_BOUND], 'o-', color=mymap(r, 1), ms=3) AX[0, 1].semilogx(m['freq'][m['freq'] < HIGH_BOUND], m['phase'][m['freq'] < HIGH_BOUND], 'o-', color=mymap(r, 1), ms=3) AX[0, 0].annotate('n=' + str(len(MICE)) + ' cells', (.2, .2), xycoords='axes fraction', fontsize=18) ax2 = fig.add_axes([0.59, 0.7, 0.015, 0.18]) cb = build_bar_legend(X, ax2, mymap, scale='linear', color_discretization=100,\ bounds=psd_boundaries, label=r'$R_\mathrm{m}$ ($\mathrm{M}\Omega$)') f_bins = np.logspace( np.log(.1) / np.log(10), np.log(HIGH_BOUND) / np.log(10), 20) digitized = np.digitize(all_freq, f_bins) psd_means = np.array( [all_psd[digitized == i].mean() for i in range(1, len(f_bins))]) psd_std = np.array( [all_psd[digitized == i].std() for i in range(1, len(f_bins))]) phase_means = np.array( [all_phase[digitized == i].mean() for i in range(1, len(f_bins))]) phase_std = np.array( [all_phase[digitized == i].std() for i in range(1, len(f_bins))]) AX[1, 0].errorbar(.5 * (f_bins[1:] + f_bins[:-1]), psd_means, yerr=psd_std, color='gray', lw=3, label='data') AX[1, 0].fill_between(.5 * (f_bins[1:] + f_bins[:-1]), psd_means - psd_std, psd_means + psd_std, color='lightgray') AX[1, 1].errorbar(.5 * (f_bins[1:] + f_bins[:-1]), phase_means, yerr=phase_std, color='gray', lw=3, label='data') AX[1, 1].fill_between(.5 * (f_bins[1:] + f_bins[:-1]), phase_means - phase_std, phase_means + phase_std, color='lightgray') ## THEN MODEL from minimization import single_comp_imped try: Rm, Cm = np.load('single_comp_fit.npy') psd, phase = single_comp_imped(f, Rm, Cm) AX[1, 0].loglog(f, psd, 'k:', lw=2) AX[1, 1].semilogx(f, phase, 'k:', lw=2, label='single comp.') except IOError: print('no single compartment data available') ### MEAN MODEL psd, phase = get_input_imped(soma, stick, params) AX[1, 0].loglog(f, psd, 'k-', alpha=.8, lw=4) AX[1, 1].semilogx(f[:-1], -phase[:-1], 'k-', alpha=.8, lw=4, label='medium size \n model') ### MODEL VARIATIONS base = np.linspace(0, 1, 4) for Rrm, b in zip([250, 350, 600, 800], base): soma1, stick1, params1 = adjust_model_prop(Rrm, soma, stick) psd, phase = get_input_imped(soma1, stick1, params1) AX[1, 0].loglog(f, psd, '-', color=mymap(b, 1), ms=5) AX[1, 1].semilogx(f[:-1], -phase[:-1], '-', color=mymap(b, 1), ms=5) ### ===================== FINAL graph settings ax3 = fig.add_axes([0.19, 0.125, 0.015, 0.18]) cb = build_bar_legend([0,1], ax3, mymap, scale='linear', color_discretization=100,\ bounds=psd_boundaries,ticks_labels=['',''], label='size variations') AX[1, 1].legend(frameon=False, prop={'size': 'x-small'}) for ax, xlabel in zip([AX[0, 0], AX[1, 0]], ['', 'frequency (Hz)']): set_plot(ax, xlim=[.08,1000], ylim=[6., 1200],\ xticks=[1,10,100,1000], yticks=[10,100,1000],yticks_labels=['10','100','1000'],\ xlabel=xlabel,ylabel='modulus ($\mathrm{M}\Omega$)') for ax, xlabel in zip([AX[0, 1], AX[1, 1]], ['', 'frequency (Hz)']): set_plot(ax, xlim=[.08,1000], ylim=[-.2,2.3],\ xticks=[1,10,100,1000], yticks=[0,np.pi/4.,np.pi/2.],\ yticks_labels=[0,'$\pi/4$', '$\pi/2$'], xlabel=xlabel, ylabel='phase shift (Rd)') fig2, ax = make_fig(np.linspace(0, 1, stick['B'] + 1) * stick['L'], stick['D'], xscale=1e-6, yscale=50e-6) fig2.set_size_inches(3, 5, forward=True) fig3 = make_conversion_fig(Rm0=Rm) return fig, fig2, fig3
cond = (time > 70) & (time < 120) mean_data = smooth_data[:, cond].mean(axis=1) fig, AX = plt.subplots(1, 2, figsize=(8, 3)) plt.subplots_adjust(bottom=.23, top=.97, right=.85) def to_minimize(x): return np.sum((mean_data - double_gaussian(space, *x))**2) res = minimize(to_minimize, [3, 6, 2, .9]) print(res.x) AX[0].plot(space, double_gaussian(space, *res.x), label='double gaussian') def to_minimize(x): return np.sum((mean_data - gaussian(space, *x))**2) res = minimize(to_minimize, [5, 2, .9]) AX[1].plot(space, gaussian(space, *res.x), label='simple gaussian') for ax in AX: ax.plot(space, mean_data, label='data [70,120] ms') ax.legend() set_plot(AX[0], xlabel='space (mm)', ylabel='VSDi signal ($\perthousand$)') set_plot(AX[1], xlabel='space (mm)') fig.savefig('/Users/yzerlaut/Desktop/1.png') plt.show()
def make_experimental_fig(): fig, AX = plt.subplots(1, 2, figsize=(8, 4)) plt.subplots_adjust(bottom=.3, left=.25, wspace=.3) f, psd_means, phase_means = np.load( '../larkumEtAl2009/data/larkum_imped_data.npy') phase_means = -phase_means AX[0].plot(f, psd_means, color='gray', lw=3, label='Layer V pyr. cell \n Larkum et al. 2009') AX[1].plot(f, phase_means, color='gray', lw=3, label='Layer V pyr. cell \n Larkum et al. 2009') ## THEN MODEL from minimization import single_comp_imped try: Rm, Cm = np.load('single_comp_fit_larkum.npy') psd, phase = single_comp_imped(f, Rm, Cm) AX[0].loglog(f, psd, 'k:', lw=2) AX[1].semilogx(f, phase, 'k:', lw=2, label='single comp.') except IOError: print('no single compartment data available') ### MEAN MODEL psd, phase = get_input_imped(soma, stick, params) AX[0].loglog(f, psd, 'k-', alpha=.8, lw=3) AX[1].semilogx(f[:-1], -phase[:-1], 'k-', alpha=.8, lw=3, label='fitted \"reduced model\"') ### ===================== FINAL graph settings AX[1].legend(frameon=False, prop={'size': 'x-small'}) set_plot(AX[0], xlim=[.08,1000], ylim=[.3, 200],\ xticks=[1,10,100,1000], yticks=[1,10,100],yticks_labels=['1','10','100'],\ xlabel='frequency (Hz)',ylabel='modulus ($\mathrm{M}\Omega$)') set_plot(AX[1], xlim=[.08,1000], ylim=[-.2,2.3],\ xticks=[1,10,100,1000], yticks=[0,np.pi/4.,np.pi/2.],\ yticks_labels=[0,'$\pi/4$', '$\pi/2$'], xlabel='frequency (Hz)', ylabel='phase shift (Rd)') # fig2, ax = make_fig(np.linspace(0, 1, stick['B']+1)*stick['L'], # stick['D'], xscale=1e-6, yscale=50e-6) # fig2.set_size_inches(3, 5, forward=True) fig3, AX = plt.subplots(1, 2, figsize=(7, 2.5)) plt.subplots_adjust(left=.3, bottom=.3) #### ================================================== ## #### COMPARING IT WITH Transfer Resistance DATA ########## #### ================================================== ## TFdata = np.load('../LarkumEtAl2009/data/larkum_Tf_Resist_data.npz') edges, bins = np.histogram(TFdata['R_transfer'], bins=50, weights=TFdata['Areas'], normed=True) AX[0].bar(bins[:-1], edges / edges.max(), width=bins[1] - bins[0], color='gray', edgecolor='gray') precision = 1e4 # params_for_cable_theory(stick, params) # setting cable membrane constants TF_model, Area = get_the_transfer_resistance_to_soma(soma, stick, params, precision=precision, with_area=True) edges, bins = np.histogram(1e-6 * TF_model, bins=precision / 5, weights=Area, normed=True) # edges = np.concatenate([np.array([0,1]), np.real(edges)]) # bins = np.concatenate([[bins.min()], bins]) bins = .5 * (bins[:-1] + bins[1:]) AX[0].plot(bins, edges / edges.max(), color='k', lw=1) set_plot(AX[0], ylabel='surfacic density \n (norm. by maximum)', xlabel='transfer resistance M$\Omega$', yticks=[0, 1]) IRdata = np.load('../LarkumEtAl2009/data/larkum_Input_Resist_data.npz') edges, bins = np.histogram(IRdata['R_input'], bins=50, weights=IRdata['Areas'], normed=True) AX[1].bar(bins[:-1], edges / edges.max(), width=bins[1] - bins[0], color='gray', edgecolor='gray') precision = 1e4 # params_for_cable_theory(stick, params) # setting cable membrane constants TF_model, Area = get_the_input_resistance(soma, stick, params, precision=precision, with_area=True) edges, bins = np.histogram(1e-6 * TF_model, bins=precision / 10, weights=Area, normed=True) # edges = np.concatenate([np.array([0,1]), np.real(edges)]) # bins = np.concatenate([[bins.min()], bins]) bins = .5 * (bins[:-1] + bins[1:]) AX[1].plot(bins, edges / edges.max(), color='k', lw=1) set_plot(AX[1], ylabel='surfacic density \n (norm. by maximum)', xlabel='input resistance M$\Omega$', yticks=[0, 1]) return fig, fig3
import matplotlib.pylab as plt args2, t, X, Fe_aff1, Fe1, Fi1, muVn1,\ Fe_aff2, Fe2, Fi2, muVn2, Fe_aff3, Fe3, Fi3, muVn3 = np.load(args.file) fig1, desambuigVSD = decode_stim(t, muVn1, muVn2, muVn3, stim_length=100e-3) fig2, desambuigFR = decode_stim(t, Fe1 - Fe1[0, :].mean(), Fe2 - Fe2[0, :].mean(), Fe3 - Fe3[0, :].mean(), stim_length=100e-3) # fig1.savefig('data/VSD.svg') # fig2.savefig('data/FR.svg') fig, ax = plt.subplots(1, figsize=(3.5, 2.5)) plt.subplots_adjust(bottom=.3, left=.3) ax.plot(1e3 * t, desambuigFR, label='Firing Rate') ax.plot(1e3 * t, desambuigVSD, label='Vm') ax.legend(prop={'size': 'x-small'}) set_plot(ax, ylabel='Desambuiguation \n $P^{AM}(2) - P^{LP}(2)$', xlabel='time (ms)') plt.show()
def decode_stim(t, S1, S2, AM, stim_length=100e-3, frame_norm=True, non_zero=1e-10): # extracting temporal quantities dt = t[1] - t[0] # time step istim = int(stim_length / dt) # duration in bins of response to determine cort. repres. # flatten over space S1 and S2 to extract onset times fS1, fS2 = S1.mean(axis=1), S2.mean(axis=1) iT1, iT2 = np.argmax(fS1), np.argmax(fS1) # mean cortical representations meanS1 = S1[iT1:iT1 + istim, :].mean(axis=0) meanS2 = S2[iT2:iT2 + istim, :].mean(axis=0) meanS12 = meanS1 + meanS2 # then normalization meanS1 /= non_zero + np.linalg.norm(meanS1) meanS2 /= non_zero + np.linalg.norm(meanS2) meanS12 /= non_zero + np.linalg.norm(meanS12) Blank = np.zeros(len(meanS1)) # blank is zero LP = S1 + S2 # linear prediction dAM, dLP = {}, { } # dictionaries that we will fill with the analysis values for key in [ 'Dev_vs_S1', 'Dev_vs_S2', 'Dev_vs_S12', 'Dev_vs_BL', 'P_S1', 'P_S2', 'P_S12', 'P_BL' ]: dAM[key], dLP[key] = np.zeros(len(t)), np.zeros( len(t)) # initialized to zeros vectos # now loop over frames to get all the deviations to get an average deviation for the proba calc # for i in [500, 1100]: for i in range(len(t)): # --> Apparent Motion nAM = AM[i, :] / (non_zero + np.linalg.norm(AM[i, :])) # --> Linear Prediction nLP = LP[i, :] / (non_zero + np.linalg.norm(LP[i, :])) # computing deviations for key, stim in zip(\ ['Dev_vs_S1', 'Dev_vs_S2', 'Dev_vs_S12', 'Dev_vs_BL'], [meanS1, meanS2, meanS12, Blank]): dAM[key][i] = np.std(nAM - stim) dLP[key][i] = np.std(nLP - stim) # now loop over frames to get all the deviations to get an average deviation for the proba calc for i in range(len(t)): # --> Apparent Motion nAM = AM[i, :] / (non_zero + np.linalg.norm(AM[i, :])) # --> Linear Prediction nLP = LP[i, :] / (non_zero + np.linalg.norm(LP[i, :])) # computing deviations Ptot_AM, Ptot_LP = 0, 0 # total proba for key1, key2, stim in zip(\ ['P_S1', 'P_S2', 'P_S12', 'P_BL'], ['Dev_vs_S1', 'Dev_vs_S2', 'Dev_vs_S12', 'Dev_vs_BL'], [meanS1, meanS2, meanS12, Blank]): dAM[key1][i] = np.exp(-0.5 * np.sum( (nAM - stim)**2 / (1e-9 + dAM[key2].std()))) + 1e-9 Ptot_AM += dAM[key1][i] dLP[key1][i] = np.exp(-0.5 * np.sum( (nLP - stim)**2 / (1e-9 + dLP[key2].std()))) + 1e-9 Ptot_LP += dLP[key1][i] for key in ['P_S1', 'P_S2', 'P_S12', 'P_BL']: dAM[key][i] /= Ptot_AM dLP[key][i] /= Ptot_LP fig, AX = plt.subplots(1, 2, figsize=(7, 2.5)) AX[0].plot(nAM) AX[0].plot(meanS1) AX[1].plot(nLP) AX[1].plot(meanS12) AX[1].plot(meanS2) plt.show() # figure fig, AX = plt.subplots(1, 2, figsize=(7, 2.5)) plt.subplots_adjust(bottom=.2, wspace=.3, hspace=.3) for key, label in zip(['P_S1', 'P_S2', 'P_S12', 'P_BL'], ['P(1)', 'P(2)', 'P(1+2)', 'P(Blank)']): for ax, D in zip(AX[:2], [dAM, dLP]): ax.plot(1e3 * t, D[key], label=label) for ax, title in zip(AX, ['App. Motion', 'Linear Pred.']): ax.legend(prop={'size': 'x-small'}) ax.set_title(title) set_plot(ax, yticks=[0, .5, 1], ylabel='Proba', xlabel='time (ms)') desambuig = dAM['P_S2'] - dLP['P_S2'] return fig, desambuig
for i in range(len(CELLS)): Rm_data[i] = 1e-6 / CELLS[i]['Gl'] soma1, stick1, params1 = adjust_model_prop(Rm_data[i], soma, stick) Rtf_model[i] = get_the_mean_transfer_resistance_to_soma( soma1, stick1, params1) print('---------------------------------------------------') print('Comparison between model and data for Tm') print('MODEL, mean = ', 1e-6 * Rtf_model.mean(), 'ms +/-', 1e-6 * Rtf_model.std()) print('---------------------------------------------------') fig, [ax, ax2] = plt.subplots(1, 2, figsize=(8, 3)) plt.subplots_adjust(bottom=.3, wspace=.4) # histogram # ax.hist(1e3*Rtf_data, color='r', label='data') ax.hist(1e-6 * Rtf_model, color='b', label='model') ax.legend(frameon=False, prop={'size': 'x-small'}, loc='best') set_plot(ax, xlabel='transfer resistance \n to soma $(M \Omega)$', ylabel='cell #') # correl Rm-Tm ax2.plot(Rm_data, 1e-6 * Rtf_model, 'ob', label='model') ax2.legend(prop={'size': 'xx-small'}, loc='best') set_plot(ax2, xlabel='somatic input \n resistance $(M \Omega)$', ylabel='transfer resistance \n to soma $(M \Omega)$') plt.show()