def fit_FA_w_init(factors=5,ntrials=100, hdf=None): rew_ix = pa.get_trials_per_min(hdf) bin_spk, targ_pos, targ_ix, trial_ix, reach_time, hdf_ix = pa.extract_trials_all(hdf, rew_ix, hdf_ix=True) if ntrials=='max': ix = np.arange(len(trial_ix)) else: ix = np.nonzero(trial_ix<=ntrials)[0] FA = skdecomp.FactorAnalysis(n_components=factors) zsc, mu = pa.zscore_spks(bin_spk[ix,:]) FA.fit(bin_spk[ix,:]) return FA, mu, trial_ix, hdf_ix, bin_spk
def fit_FA_by_targ(factors=5, ntrials='max', hdf=None): rew_ix = pa.get_trials_per_min(hdf) bin_spk, targ_pos, targ_ix, trial_ix, reach_time, hdf_ix = pa.extract_trials_all(hdf, rew_ix, hdf_ix=True) if ntrials=='max': ix_cutoff = len(trial_ix) else: ix_cutoff = len(np.nonzero(trial_ix<=ntrials)[0]) FA_dict = dict() mu_dict = dict() for tg in np.unique(targ_ix): tg_ix = np.nonzero(targ_ix==tg)[0] tg_ix = tg_ix[tg_ix<ix_cutoff] FA = skdecomp.FactorAnalysis(n_components=factors) zsc, mu = pa.zscore_spks(bin_spk[tg_ix,:]) FA.fit(bin_spk[tg_ix,:]) FA_dict[str(tg)] = FA mu_dict[str(tg)] = mu print 'done with target: ', str(tg) return FA_dict, mu_dict, trial_ix, hdf_ix, bin_spk, targ_ix
def process_targets(te_list, new_hdf_name): ''' Summary: Yields an array of trial information in pytables with columns seen above in Trial_Metrics table class Input param: hdf: hdf for either fa_bmi or bmi_resetting Output param: trial dictionary ''' h5file = tables.openFile(new_hdf_name, mode="w", title='FA Trial Analysis') trial_mets_table = h5file.createTable("/", 'trial_metrics', Trial_Metrics, "Trial Mets") meta_table = h5file.createTable("/", 'meta_metrics', Meta_Metrics, "Meta Mets") row_cnt = -1 for te in te_list: te_obj = dbfn.TaskEntry(te) task_entry = te hdf = te_obj.hdf #Extract trials ignoring assist: rew_ix, rew_per_min = pa.get_trials_per_min(hdf, nmin=2, rew_per_min_cutoff=0, ignore_assist=True, return_rpm=True) #Go backwards 3 steps (rew --> targ trans --> hold --> target (onset)) go_ix = np.array([hdf.root.task_msgs[it-3][1] for it, t in enumerate(hdf.root.task_msgs[:]) if scipy.logical_and(t[0] == 'reward', t[1] in rew_ix)]) assert len(rew_ix) == len(go_ix)#: raise Exception("Rew ix and Go ix are unequal") #Time to target is diff b/w target onset and reward time time2targs = (rew_ix - go_ix)/60. #Add buffer of 5 task steps (80 ms) target_locs = hdf.root.task[go_ix.astype(int) + 5]['target'][:, [0, 2]] try: obstacle_sz = hdf.root.task[go_ix.astype(int) + 5]['obstacle_size'][:, 0] except: obstacle_sz = np.zeros_like(go_ix) #Targ ix -- should be 8 targ_ixs = pa.get_target_ix(target_locs) assert len(np.unique(targ_ixs)) == 8#: raise Exception("Target Ix has more or less than 8 targets :/ ") #Input type: try: input_types = hdf.root.task[go_ix.astype(int)+5]['fa_input'] except: input_types = ['all']*len(go_ix) rew_time_2_trial = {} for ri, r_ix in enumerate(rew_ix): trl = trial_mets_table.row row_cnt += 1 trl['trial_number'] = ri trl['task_entry'] = task_entry trl['rew_per_min'] = rew_per_min[ri] trl['target_index'] = targ_ixs[ri] trl['target_loc'] = target_locs[ri,:] trl['start_time'] = go_ix[ri]/60. # In seconds trl['input_type'] = input_types[ri] trl['time2targ'] = time2targs[ri] rew_time_2_trial[r_ix] = time2targs[ri] trl['obstacle_size'] = obstacle_sz[ri] path = hdf.root.task[int(go_ix[ri]):int(r_ix)]['cursor'][:, [0, 2]] path_length, path_error, avg_speed = path_metrics(path, target_locs[ri, :]) trl['path_length'] = path_length trl['path_error'] = path_error trl['avg_speed'] = avg_speed trl['timeout_time'] = hdf.root.task.attrs.timeout_time trl['timeout_penalty_time'] = hdf.root.task.attrs.timeout_penalty_time trl.append() trial_mets_table.flush() #Meta metrics for hdf: block_len = hdf.root.task.shape[0] wind_len = 5*60*60 wind_step = 2.5*60*60 meta_ix = np.arange(0, block_len - wind_len, wind_step) trial_ix = np.array([i for i in hdf.root.task_msgs[:] if i['msg'] in ['reward','timeout_penalty','hold_penalty','obstacle_penalty'] ], dtype=hdf.root.task_msgs.dtype) for m in meta_ix: meta_trl = meta_table.row meta_trl['task_entry'] = te end_meta_ix = m + wind_len trial_ix_time = trial_ix[:,] msg_ix = np.nonzero(np.logical_and(trial_ix['time']<=end_meta_ix, trial_ix['time']>m))[0] targ = hdf.root.task[trial_ix[msg_ix]['time'].astype(int)]['target'][:,[0,2]] targ_ix = pa.get_target_ix(targ) #Only mark as correct if it's the first correct trial targ_ix_ix = [0] tg_prev = targ_ix[0] for ii, tg_ix in enumerate(targ_ix[1:]): if tg_prev != tg_ix: targ_ix_ix.append(ii+1) tg_prev = tg_ix targ_ix_mod = targ_ix[targ_ix_ix] msg_ix_mod = msg_ix[targ_ix_ix] targ_percent_success = np.zeros((8, )) - 1 all_perc_succ_lte10sec = np.zeros((8, )) - 1 #time2targs for rew_ix: rew_ix_meta = np.array([i['time'] for i in trial_ix[msg_ix] if i['msg']=='reward']) for t in range(8): t_ix = np.nonzero(targ_ix_mod==t)[0] msgs = trial_ix[msg_ix_mod[t_ix]] if len(msgs) > 0: targ_percent_success[t] = len(np.nonzero(msgs['msg']=='reward')[0]) / float(len(msgs)) msgs_copy = msgs.copy() for mc in msgs_copy: if mc['msg'] == 'reward': r_tm = mc['time'] if r_tm in rew_time_2_trial.keys(): if rew_time_2_trial[r_tm] > 10.: msgs_copy['msg'] = 'not_reward' print 'not reward: ', m, t, mc else: print 'asissted: ', m, t, mc msgs_copy['msg'] = 'not_rewarded' all_perc_succ_lte10sec[t] = len(np.nonzero(msgs_copy['msg'] == 'reward')[0]) / float(len(msgs_copy)) if all_perc_succ_lte10sec[t] < 0: print 'error: ', m, t, mc else: print 'no msgs for this epoch: ', m meta_trl['targ_percent_success'] = targ_percent_success meta_trl['all_perc_succ_lte10sec'] = all_perc_succ_lte10sec all_msg = trial_ix[msg_ix_mod] meta_trl['all_percent_success'] = len(np.nonzero(all_msg['msg']=='reward')[0]) / float(len(all_msg)) meta_trl.append() meta_table.flush() #How many 5 min segments in 2.5 min steps h5file.close() return new_hdf_name
def parse_task_entry_halves(te_num, hdf, decoder, epoch_1_end=10., epoch_2_end = 20.): drives_neurons_ix0 = 3 #Get FA dict: rew_ix = pa.get_trials_per_min(hdf) half_rew_ix = np.floor(len(rew_ix)/2.) bin_spk, targ_pos, targ_ix, trial_ix, reach_time, hdf_ix = pa.extract_trials_all(hdf, rew_ix[:half_rew_ix], hdf_ix=True, drives_neurons_ix0=3) from tasks.factor_analysis_tasks import FactorBMIBase FA_dict = FactorBMIBase.generate_FA_matrices(None, bin_spk=bin_spk) #Get BMI update IX: internal_state = hdf.root.task[:]['internal_decoder_state'] update_bmi_ix = np.nonzero(np.diff(np.squeeze(internal_state[:, drives_neurons_ix0, 0])))[0]+1 epoch1_ix = int(np.nonzero(update_bmi_ix > int(epoch_1_end*60*60))[0][0]) epoch2_ix = int(np.nonzero(update_bmi_ix > int(epoch_2_end*60*60))[0][0]) #Get spike coutns and bin them: spike_counts = hdf.root.task[:]['spike_counts'][:,:,0] bin_spk_cnts = np.zeros((epoch1_ix, spike_counts.shape[1])) bin_spk_cnts2 = np.zeros((epoch2_ix, spike_counts.shape[1])) for ib, i_ix in enumerate(update_bmi_ix[:epoch1_ix]): #Inclusive of EndBin bin_spk_cnts[ib,:] = np.sum(spike_counts[i_ix-5:i_ix+1,:], axis=0) for ib, i_ix in enumerate(update_bmi_ix[:epoch2_ix]): #Inclusive of EndBin bin_spk_cnts2[ib,:] = np.sum(spike_counts[i_ix-5:i_ix+1,:], axis=0) kin = hdf.root.task[update_bmi_ix[:epoch1_ix]]['cursor'] binlen = decoder.binlen velocity = np.diff(kin, axis=0) * 1./binlen velocity = np.vstack([np.zeros(kin.shape[1]), velocity]) kin = np.hstack([kin, velocity]) ssm = decoder.ssm units = decoder.units #Shared and Scaled Shared Decoders: T = bin_spk_cnts.shape[0] demean = bin_spk_cnts.T - np.tile(FA_dict['fa_mu'], [1, T]) decoder_demn = train.train_KFDecoder_abstract(ssm, kin.T, demean, units, 0.1) decoder_demn.kin = kin.T decoder_demn.neur = demean decoder_demn.target = hdf.root.task[update_bmi_ix[:epoch1_ix]]['target'] main_shar = FA_dict['fa_main_shared'] * demean #main_priv = demean - main_shar main_sc_shar = np.multiply(main_shar, np.tile(FA_dict['fa_main_shared_sc'], [1, T])) #full_sc = np.multiply(demean, np.tile(FA_dict['fa_main_shared_sc'], [1,T])) #main_sc_shar_pls_priv = main_sc_shar + main_priv decoder_shar = train.train_KFDecoder_abstract(ssm, kin.T, main_shar, units, 0.1) decoder_shar.kin = kin.T decoder_shar.neur = main_shar decoder_sc_shar = train.train_KFDecoder_abstract(ssm, kin.T, main_sc_shar, units, 0.1) decoder_sc_shar.kin = kin.T decoder_sc_shar.neur = main_sc_shar decs_all = dict(dmn=decoder_demn, shar = decoder_shar, sc_shar = decoder_sc_shar) return decoder_full, decoder_shar, decoder_sc_shar, bin_spk_cnts2, epoch1_ix, epoch2_ix, update_bmi_ix, FA_dict
def plot_traj(R, plot_pos=1, plot_vel=1, plot_force=0, it_cutoff=20000, min_it_cutoff=0, input_type='all'): rew_ix = pa.get_trials_per_min(R.hdf,nmin=2) go_ix = np.array([R.hdf.root.task_msgs[it-3][1] for it, t in enumerate(R.hdf.root.task_msgs[:]) if t[0] == 'reward']) #Make sure no assist is used try: zero_assist_start = np.nonzero(R.hdf.root.task[:]['assist_level']==0)[0][0] except: print 'ignoring assist' zero_assist_start = 0 keep_ix = scipy.logical_and(go_ix>np.max([min_it_cutoff, zero_assist_start+(60*60)]), go_ix<it_cutoff) go_ix = go_ix[keep_ix] rew_ix = rew_ix[keep_ix] targ_pos = R.hdf.root.task[go_ix.astype(int)+5]['target'] targ_ix = pa.get_target_ix(targ_pos[:,[0, 2]]) if plot_pos == 1: f, ax = plt.subplots(nrows=4, ncols=2) f2, ax2 = plt.subplots(nrows=4, ncols=2) f0, ax0 = plt.subplots() if plot_vel == 1: f3, ax3 = plt.subplots(nrows=4, ncols=2) f4, ax4 = plt.subplots(nrows=4, ncols=2) if plot_force ==1: f5, ax5 = plt.subplots(nrows=4, ncols=2) f6, ax6 = plt.subplots(nrows=4, ncols=2) #R = pickle.load(open(pkl_name)) for i, (g,r) in enumerate(zip(go_ix, rew_ix)): #Choose axis: targ = targ_ix[i] if plot_pos == 1: axi = ax[targ%4, targ/4] axi2 = ax2[targ%4, targ/4] axi.plot(R.cursor_pos[g:r, 0], 'k-') axi2.plot(R.cursor_pos[g:r, 2], 'k-') axi.plot(R.decoded_pos[input_type][g:r, 0], 'b-') axi2.plot(R.decoded_pos[input_type][g:r, 2], 'b-') ax0.plot(R.cursor_pos[g:r,0], R.cursor_pos[g:r, 2], '-', color='k') ax0.plot(R.decoded_pos[input_type][g:r,0], R.decoded_pos[input_type][g:r, 2], '--', color=cmap_list[int(targ)]) if i==0: axi.set_title('Position X') axi2.set_title('Position Z') if plot_vel == 1: axi3 = ax3[targ%4, targ/4] axi4 = ax4[targ%4, targ/4] axi3.plot(R.cursor_vel[g:r, 0], 'k-') axi4.plot(R.cursor_vel[g:r, 2], 'k-') axi3.plot(R.decoded_vel[input_type][g:r, 0], 'b-') axi4.plot(R.decoded_vel[input_type][g:r, 2], 'b-') if i==0: axi3.set_title('Vel X') axi4.set_title('Vel Z') if plot_force ==1: axi5 = ax5[targ%4, targ/4] axi6 = ax6[targ%4, targ/4] axi5.plot(R.dec_state_mn[input_type][g-1:r-1, 9], 'b-') axi6.plot(R.dec_state_mn[input_type][g-1:r-1, 11], 'b-') axi5.plot(hdf.root.task[g:r]['internal_decoder_state'][:,9], 'k-') axi6.plot(hdf.root.task[g:r]['internal_decoder_state'][:,11], 'k-') if i==0: axi5.set_title('Acc X') axi6.set_title('Acc Z') plt.tight_layout()
def traj_sem_plot(R, input_type_root, fa_by_targ=False, it_start=0, it_cutoff=20000, ax=None, rm_assist=True, extra_title_text=''): rew_ix = pa.get_trials_per_min(R.hdf,nmin=2) go_ix = np.array([R.hdf.root.task_msgs[it-3][1] for it, t in enumerate(R.hdf.root.task_msgs[:]) if t[0] == 'reward']) if rm_assist: zero_assist_start = np.nonzero(R.hdf.root.task[:]['assist_level']==0)[0] if len(zero_assist_start) > 0: zero_assist_start = zero_assist_start[0] else: Exception('Assist is never == 0!') else: zero_assist_start = 0 start_ix = np.max([zero_assist_start, it_start]) keep_ix = scipy.logical_and(go_ix>start_ix, go_ix<it_cutoff) go_ix = go_ix[keep_ix] rew_ix = rew_ix[keep_ix] t2targ = rew_ix - go_ix targ_pos = R.hdf.root.task[go_ix.astype(int)+5]['target'] targ_ix = pa.get_target_ix(targ_pos[:,[0, 2]]) #For each target, make array of trials x time (min length for reward trial) trial_arr = dict() if ax is None: f, ax = plt.subplots() #For each target, concat trials: for it, t in enumerate(np.unique(targ_ix)): if fa_by_targ: input_type = input_type_root + '_'+str(t) else: input_type = input_type_root print input_type, R.decoded_pos[input_type].shape t_ix = np.nonzero(targ_ix==t)[0] trial_arr[str(t)] = np.zeros((len(t_ix), np.max(t2targ[t_ix]), 2)) trial_arr[str(t)][:,:] = np.nan cix = 0 for i, ti in enumerate(t_ix): if rew_ix[ti]<= R.decoded_pos[input_type].shape[0]: cix = go_ix[ti].copy() trial_arr[str(t)][i,:t2targ[ti], :] = R.decoded_pos[input_type][go_ix[ti]:rew_ix[ti],[0,2]] ax.plot(trial_arr[str(t)][i,:,0], trial_arr[str(t)][i,:,1], '-', color='lightgrey') #Plot Mean, sem: mean = np.nanmean(trial_arr[str(t)], axis=0) sem = np.nanstd(trial_arr[str(t)], axis=0)/np.sqrt(trial_arr[str(t)].shape[0]) ax.plot(mean[:,0], mean[:,1], '-',color=cmap_list[it]) ax.plot(mean[:,0] - sem[:,0], mean[:,1] - sem[:,1], '--',color=cmap_list[it]) ax.plot(mean[:,0] + sem[:,0], mean[:,1] + sem[:,1], '--',color=cmap_list[it]) tmp_circ = plt.Circle(targ_pos[t_ix[0],[0,2]], R.target_rad, color=cmap_list[it], alpha=.5) ax.add_artist(tmp_circ) ax.set_title(input_type_root + extra_title_text) ax.set_xlim([-14, 14]) ax.set_ylim([-12, 12]) return ax
def targ_vs_all_subspace_align(te_list, file_name=None, cycle_FAs=None, epoch_size=50, compare_to_orig_te = False): ''' Summary: function that takes a task entry list, parses each task entry into epochs, and computes a factor analysis model for each epoch using (1:cycle_FAs = number of factors), and then either saves or returns the output and a modified task list Input param: te_list: list of task entries (not tiered) Input param: file_name: name to save overlap data to afterwards, if None, then returns args Input param: cycle_FAs: number of factors to cycle through (1:cycle_FAs) -- uses optimal number if None Input param: epoch_size: size of epochs to parse task entries into (uses ONLY reward trials) Input param: compare_to_orig_te: if True, then also compares all of the compute FAs to the original FA model in the hdf file of the task entry listed in 'compare to original te' Output param: ''' fa_dict = {} te_list = np.array(te_list) te_mod_list = [] #assume no more than 10 FA epochs per task entry mod_increment = 0.01 increment_offs = 0.1 #For each TE get the right FA model: for te in te_list: t = dbfn.TaskEntry(te) hdf = t.hdf #Now get the right FA model: drives_neurons_ix0 = 3 rew_ix_total = pa.get_trials_per_min(hdf) #Epoch rew_ix into epochs of 'epoch_size' internal_state = hdf.root.task[:]['internal_decoder_state'] update_bmi_ix = np.nonzero(np.diff(np.squeeze(internal_state[:, drives_neurons_ix0, 0])))[0]+1 more_epochs = 1 cnt = 0 while more_epochs: #If not enough trials, still use TE, or if not epoch size specified if (epoch_size is None) or (len(rew_ix_total) < epoch_size): bin_spk, targ_pos, targ_ix, z, zz = pa.extract_trials_all(hdf, rew_ix_total, update_bmi_ix=update_bmi_ix) more_epochs = 0 te_mod = float(te) else: if (cnt+1)*epoch_size <= len(rew_ix_total): rew_ix = rew_ix_total[cnt*epoch_size:(cnt+1)*epoch_size] if len(rew_ix) != epoch_size: print moose #Only use rew indices for that epoch: bin_spk, targ_pos, targ_ix, z, zz = pa.extract_trials_all(hdf, rew_ix, time_cutoff=1000, update_bmi_ix=update_bmi_ix) te_mod = float(te) + (mod_increment*cnt) + increment_offs cnt += 1 #Be done if next epoch won't have enought trials if (cnt+1)*epoch_size > len(rew_ix_total): print (cnt+1)*epoch_size, len(rew_ix_total) more_epochs = 0 #Add modified te to dictionary te_mod_list.append(te_mod) #Use the bin_spk from above zscore_X, mu = pa.zscore_spks(bin_spk) n_neurons = zscore_X.shape[1] #If no assigned number of factors to cycle through, find optimal if cycle_FAs is None: log_lik, ax = pa.find_k_FA(zscore_X, iters=10, max_k = n_neurons, plot=False) mn_log_like = np.mean(log_lik, axis=0) ix = np.argmax(mn_log_like) num_factors = ix + 1 FA_full = skdecomp.FactorAnalysis(n_components = num_factors) FA_full.fit(zscore_X) fa_dict[te, 0] = FA_full fa_dict['units', te] = t.decoder.units else: for i in np.arange(1, cycle_FAs+1): FA = skdecomp.FactorAnalysis(n_components = i) FA.fit(zscore_X) fa_dict[te_mod, i] = FA #Now FA dict is completed: print 'now computing overlaps', te_mod_list if file_name is None: d, te_mod = ss_overlap(cycle_FAs, te_mod_list, fa_dict, file_name=file_name, compare_to_orig_te=compare_to_orig_te) return d, te_mod else: ss_overlap(cycle_FAs, te_mod_list, fa_dict, file_name=file_name, compare_to_orig_te=compare_to_orig_te)
vfb_te = 3997 bmi_cal_te = 3999 bmi_fa_te = 4000 n_factors = [2, 3, 5, 7] n_reps = 5 import dbfunctions as dbfn import prelim_analysis as pa import sklearn.decomposition as skdecomp from online_analysis import spk_from_vfb as sfv test_data = dbfn.TaskEntry(bmi_fa_te) rew_ix = pa.get_trials_per_min(test_data.hdf) test_bin_spk, targ_pos, targ_ix, z, zz = pa.extract_trials_all(test_data.hdf, rew_ix) #Training paradigms: train_data = dbfn.TaskEntry(bmi_cal_te) train_rew_ix = pa.get_trials_per_min(train_data.hdf) vfb = dbfn.TaskEntry(vfb_te) rew_ix = pa.get_trials_per_min(vfb.hdf) vfb_bin_spk = sfv.get_vfb_spk(vfb, rew_ix, train_data.decoder.units) train_param = ['vfb']+range(8,64,8) LL = np.zeros((len(train_param), len(n_factors), n_reps)) for it, tr in enumerate(train_param): if tr == 'vfb':