def train_arnet(self, start_params): arnet_autograd_func = grad(arnet_cost_function) arnet_bounds = [(0, 1)] * len(start_params) + [(0, 1)] * self.num_src iter_cnt = 0 pred_train_output_mat = np.empty((0, len(self.true_train_output)), np.float) pred_test_output_mat = np.empty((0, self.num_output), np.float) link_weights_list = np.empty((0, self.num_src), np.float) network_ratio_list = [] while iter_cnt < self.num_ensemble: arnet_init_values = np.array(start_params + [np.random.random()] * self.num_src) arnet_optimizer = optimize.minimize(arnet_cost_function, arnet_init_values, jac=arnet_autograd_func, method='L-BFGS-B', args=(self.train_input, self.true_train_output), bounds=arnet_bounds, options={'maxiter': 100, 'disp': False}) arnet_fitted_params = arnet_optimizer.x # arnet_ar_coef = arnet_fitted_params[: self.num_input] arnet_link_weights = arnet_fitted_params[self.num_input:] arnet_pred_train, arnet_latent_train = arnet_predict(arnet_fitted_params, self.train_input, mode='train') arnet_pred_test, arnet_latent_test = arnet_predict(arnet_fitted_params, self.test_input, mode='test') pred_train_output_mat = np.vstack((pred_train_output_mat, arnet_pred_train)) pred_test_output_mat = np.vstack((pred_test_output_mat, arnet_pred_test)) link_weights_list = np.vstack((link_weights_list, arnet_link_weights)) network_ratio_list.append(1 - sum(arnet_latent_train) / sum(arnet_pred_train)) iter_cnt += 1 self.pred_train_output = np.nanmean(pred_train_output_mat, axis=0) self.pred_test_output = np.nanmean(pred_test_output_mat, axis=0) self.link_weights = np.nanmean(link_weights_list, axis=0) self.network_ratio = np.mean(network_ratio_list)
def standard_normalizer(self, x): # compute the mean and standard deviation of the input x_means = np.nanmean(x, axis=1)[:, np.newaxis] x_stds = np.nanstd(x, axis=1)[:, np.newaxis] # check to make sure thta x_stds > small threshold, for those not # divide by 1 instead of original standard deviation ind = np.argwhere(x_stds < 10**(-2)) if len(ind) > 0: ind = [v[0] for v in ind] adjust = np.zeros((x_stds.shape)) adjust[ind] = 1.0 x_stds += adjust # fill in any nan values with means ind = np.argwhere(np.isnan(x) == True) for i in ind: x[i[0], i[1]] = x_means[i[0]] # create standard normalizer function normalizer = lambda data: (data - x_means) / x_stds # create inverse standard normalizer inverse_normalizer = lambda data: data * x_stds + x_means # return normalizer return normalizer, inverse_normalizer
def ori_avg(Rs,these_ori_dirs): if fit_sc: rs_sc = np.nanmean(Rs[:nsc].reshape((nrun,nsize,ncontrast,ndir))[:,:,:,these_ori_dirs],-1) rs_sc[:,1:,1:] = ssi.convolve(rs_sc,kernel,'valid') rs_sc = rs_sc.reshape((nrun*nsize*ncontrast)) if fit_fg: rs_fg = np.nanmean(Rs[nsc:].reshape((nrun,nstim_fg,ndir))[:,:,these_ori_dirs],-1) rs_fg = rs_fg.reshape((nrun*nstim_fg)) else: rs_fg = np.zeros((0,)) elif fit_fg: rs_sc = np.zeros((0,)) rs_fg = np.nanmean(Rs.reshape((nrun,nstim_fg,ndir))[:,:,these_ori_dirs],-1) rs_fg = rs_fg.reshape((nrun*nstim_fg)) Rso = np.concatenate((rs_sc,rs_fg)) return Rso
def compute_R_hat(chains, warmup=500): #first axis is relaisations, second is iters # N_realisations X N_iters X Ndims jitter = 1e-8 chains = chains[:, warmup:, :] n_iters = chains.shape[1] n_chains = chains.shape[0] K = chains.shape[2] if n_iters % 2 == 1: n_iters = int(n_iters - 1) chains = chains[:, :n_iters - 1, :] n_iters = n_iters // 2 psi = np.reshape(chains, (n_chains * 2, n_iters, K)) n_chains2 = n_chains * 2 psi_dot_j = np.mean(psi, axis=1) psi_dot_dot = np.mean(psi_dot_j, axis=0) s_j_2 = np.sum( (psi - np.expand_dims(psi_dot_j, axis=1))**2, axis=1) / (n_iters - 1) B = n_iters * np.sum( (psi_dot_j - psi_dot_dot)**2, axis=0) / (n_chains2 - 1) W = np.nanmean(s_j_2, axis=0) W = W + jitter var_hat = (n_iters - 1) / n_iters + (B / (n_iters * W)) R_hat = np.sqrt(var_hat) return var_hat, R_hat
def advi_callback(params, t, g, results, delta_results, model, eval_function, hparams): results.append(eval_function(params)) if (t + 1) % hparams['advi_callback_iteration'] == 0: if len(results) > hparams['advi_callback_iteration']: previous_elbo = results[-(hparams['advi_callback_iteration'] + 1)] else: previous_elbo = 0.0 current_elbo = results[-1] delta_results.append(relative_difference(previous_elbo, current_elbo)) delta_elbo_mean = np.nanmean(delta_results) delta_elbo_median = np.nanmedian(delta_results) if ((delta_elbo_median <= hparams['advi_convergence_threshold']) | (delta_elbo_mean <= hparams['advi_convergence_threshold'])): tqdm.write(f"Converged early according to ADVI " f"metrics for Median/Mean") tqdm.write(f"Iteration {t+1}") tqdm.write(f"Rel. tolerance Δ threshold: " f"{hparams['advi_convergence_threshold']}") tqdm.write(f"Rel. tolerance Δ mean: {delta_elbo_mean:.5f}") tqdm.write(f"Rel. tolerance Δ median: {delta_elbo_median:.5f}") return "exit" return None
def standardize(data, mask): data[~mask] = np.nan m = np.nanmean(data, axis=0) s = np.nanstd(data, axis=0) s[~np.any(mask, axis=0)] = 1 y = (data - m) / s assert np.all(np.isfinite(y)) return y
def optimize_kappa(data,x0=None,cost_fn=svm_cost,args=()): # given data, optimize (kappa, amplitude) inputs to svm_fn(), and return kappa if x0 is None: x0 = np.array((1,np.nanmean(data))) this_cost_fn = lambda x: cost_fn(x,data,*args) this_grad = grad(this_cost_fn) result = sop.minimize(this_cost_fn,x0,bounds=[(0,np.inf),(0,np.inf)],method='L-BFGS-B',jac=this_grad) kappa,amplitude = result.x return kappa,amplitude
def train_lstm(self): num_epochs = 100 # sanity check: check the shape of train input, train output, and test input # print('shape of train input: {0}, train output: {1}, test input: {2}'.format(self.train_input.shape, self.train_output.shape, self.test_input.shape)) callbacks = [EarlyStopping(monitor='val_loss', patience=10)] iter_cnt = 0 pred_train_output_mat = np.empty((0, self.len_train_output), np.float) pred_test_output_mat = np.empty((0, self.num_output), np.float) while iter_cnt < self.num_ensemble: self.history = self.model.fit(self.train_input, self.train_output, validation_split=0.15, shuffle=False, batch_size=1, epochs=num_epochs, callbacks=callbacks, verbose=0) # get the predicted train output pred_train_output = self.model.predict(self.train_input) pred_train_output_mat = np.zeros(shape=(self.num_output, self.len_train_output), dtype=np.float) pred_train_output_mat.fill(np.nan) for i in range(self.num_sequence): seq_pred_train_output = post_process_results(pred_train_output[i], denom=self.train_denom_list[i], ts_seasonality_in=self.ts_seasonality_in, shift=i, freq=self.freq).ravel() pred_train_output_mat[i % self.num_output, i: i + self.num_output] = seq_pred_train_output iter_pred_train_output = np.nanmean(pred_train_output_mat, axis=0) iter_train_smape, _ = smape(self.true_train_output, iter_pred_train_output) if iter_train_smape < 150: # get the predicted test output iter_pred_test_output = self.model.predict(self.test_input).ravel() iter_pred_test_output = post_process_results(iter_pred_test_output, denom=self.test_denom, ts_seasonality_in=self.ts_seasonality_in, shift=self.len_train_output, freq=self.freq).ravel() pred_train_output_mat = np.vstack((pred_train_output_mat, iter_pred_train_output)) pred_test_output_mat = np.vstack((pred_test_output_mat, iter_pred_test_output)) iter_cnt += 1 self.pred_train_output = np.nanmean(pred_train_output_mat, axis=0) self.pred_test_output = np.nanmean(pred_test_output_mat, axis=0)
def sigma_clip(t, y, yerr, mask=None): if mask is not None: m = np.copy(mask) else: m = np.ones(len(t), dtype=bool) while True: mu = np.nanmean(y[m]) sig = np.nanstd(y[m]) m0 = y - mu < 3 * sig if np.all(m0 == m): break m = m0 #t, y, yerr = t[m], y[m], yerr[m] return m
def compute_R_hat(chains, warmup=0.5): """ Compute the split-R-hat for multiple chains, all the chains are split into two and the R-hat is computed over them before removing the 'warmup' iterates if desired. Parameters ---------- chains : multi-dimensional array, shape=(n_chains, n_iters, n_var_params) Returns ------- var_hat : var-hat computed in BDA R_hat: the split R-hat for multiple chains """ jitter = 1e-8 n_iters = chains.shape[1] n_chains = chains.shape[0] if warmup < 1: warmup = int(warmup * n_iters) if warmup > n_iters - 2: raise ValueError('Warmup should be less than number of iterates ..') if (n_iters - warmup) % 2: warmup = int(warmup + 1) chains = chains[:, warmup:, :] K = chains.shape[2] n_iters = chains.shape[1] n_iters = int(n_iters // 2) psi = np.reshape(chains, (n_chains * 2, n_iters, K)) n_chains2 = n_chains * 2 psi_dot_j = np.mean(psi, axis=1) psi_dot_dot = np.mean(psi_dot_j, axis=0) s_j_2 = np.sum( (psi - np.expand_dims(psi_dot_j, axis=1))**2, axis=1) / (n_iters - 1) B = n_iters * np.sum( (psi_dot_j - psi_dot_dot)**2, axis=0) / (n_chains2 - 1) W = np.nanmean(s_j_2, axis=0) W = W + jitter var_hat = (n_iters - 1) / n_iters + (B / (n_iters * W)) R_hat = np.sqrt(var_hat) return var_hat, R_hat
def compute_rotated_map(self, rotation): """ Compute stellar maps projected on the plane of the sky for a given rotation of the star Args: rotation (float) : rotation around the star in degrees given as [longitude, latitude] in degrees Returns: pixel_unique (int) : vector with the "active" healpix pixels pixel_map (int) : map showing the healpix pixel projected on the plane of the sky mu_pixel (float): map of the astrocentric angle for each pixel on the plane of the sky (zero for pixels not in the star) T_pixel (float): map of temperatures for each pixel on the plane of the sky """ mu_pixel = np.zeros_like(self.mu_angle) T_pixel = np.zeros_like(self.mu_angle) # Get the projection of the healpix pixel indices on the plane of the sky pixel_map = self.projector.projmap(self.indices, self.f_vec2pix, rot=rotation)[:,0:int(self.npix/2)] # Get the unique elements in the vector pixel_unique = np.unique(pixel_map) # Now loop over all unique pixels, filling up the array of the projected map with the mu and temeperature values for j in range(len(pixel_unique)): ind = np.where(pixel_map == pixel_unique[j]) if (np.all(np.isfinite(self.mu_angle[ind[0],ind[1]]))): if (self.mu_angle[ind[0],ind[1]].size == 0): value = 0.0 else: value = np.nanmean(self.mu_angle[ind[0],ind[1]]) mu_pixel[ind[0],ind[1]] = value T_pixel[ind[0],ind[1]] = self.temperature_map[int(pixel_unique[j])] else: mu_pixel[ind[0],ind[1]] = 0.0 T_pixel[ind[0],ind[1]] = 0.0 return pixel_unique, pixel_map, mu_pixel, T_pixel
def compute_R_hat(chains, warmup=0, jitter=1e-8): """ Computing R hat values using split R hat approach Parameters ---------- chains : `numpy_ndarray(n_iters, dimensions)` Sample of parameter estimates that has one chain warmup : `int`, optional Number of iterations needed for warmup. The default is 0. jitter : `float`, optional Smoothing term that avoids division by zero. The default is 1e-8. Returns ------- R_hat : `numpy_ndarray(dimenstions,)` Computed R hat values for each parameter """ n_chains = 1 chains = chains[warmup:,:] n_iters, d = chains.shape if n_iters%2 ==1: n_iters = int(n_iters-1) chains = chains[:n_iters,:] n_iters = n_iters // 2 n_chains2 = n_chains *2 psi = np.reshape(chains,(n_chains2,n_iters,d)) psi_dot_j = np.mean(psi,axis=1) psi_dot_dot = np.mean(psi_dot_j,axis=0) s_j_2 = np.sum((psi - np.expand_dims(psi_dot_j, axis=1)) ** 2, axis=1) / (n_iters - 1) B = n_iters * np.sum((psi_dot_j - psi_dot_dot) ** 2, axis=0) / (n_chains2 - 1) W = np.nanmean(s_j_2, axis=0) W = W + jitter var_hat = (n_iters - 1) / n_iters + (B / (n_iters*W)) R_hat = np.sqrt(var_hat) return R_hat
def average_time(arr, nbefore=8, nafter=8): # average across time points and directions ndim = len(arr.shape) slicer = [slice(None) for idim in range(ndim)] slicer[-1] = slice(nbefore, -nafter) return np.nanmean(arr[slicer], -1)
def compute_tuning(dsfile, datafield='decon', running=True, expttype='size_contrast_0', running_pct_cutoff=default_running_pct_cutoff, fill_nans_under_cutoff=False, run_speed_cutoff=default_run_speed_cutoff): # take in an HDF5 data struct, and convert to an n-dimensional matrix # describing the tuning curve of each neuron. For size-contrast stimuli, # the dimensions of this matrix are ROI index x size x contrast x direction x time. # This outputs a list of such matrices, where each element is one imaging session with h5py.File(dsfile, mode='r') as f: keylist = [key for key in f.keys()] tuning = [None for i in range(len(keylist))] uparam = [None for i in range(len(keylist))] displacement = [None for i in range(len(keylist))] pval = [None for i in range(len(keylist))] for ikey in range(len(keylist)): session = f[keylist[ikey]] print(session) #print([key for key in session.keys()]) if expttype in session and datafield in session[expttype]: sc0 = session[expttype] print(datafield) data = sc0[datafield][:] stim_id = sc0['stimulus_id'][:] nbefore = sc0['nbefore'][()] nafter = sc0['nafter'][()] if running: trialrun = sc0[ 'running_speed_cm_s'][:, nbefore:-nafter].mean( -1) > run_speed_cutoff # else: trialrun = sc0['running_speed_cm_s'][:, nbefore:-nafter].mean( -1 ) < run_speed_cutoff #print(sc0['running_speed_cm_s'].shape) print(np.nanmean(trialrun)) if np.nanmean(trialrun) > running_pct_cutoff: tuning[ikey] = ut.compute_tuning( data, stim_id, trial_criteria=trialrun)[:] elif fill_nans_under_cutoff: tuning[ikey] = ut.compute_tuning( data, stim_id, trial_criteria=trialrun)[:] tuning[ikey] = np.nan * np.ones_like(tuning[ikey]) uparam[ikey] = [] for param in sc0['stimulus_parameters']: uparam[ikey] = uparam[ikey] + [sc0[param][:]] if 'rf_displacement_deg' in sc0: pval[ikey] = sc0['rf_mapping_pval'][:] sqerror = session['retinotopy_0']['rf_sq_error'][:] sigma = session['retinotopy_0']['rf_sigma'][:] X = session['cell_center'][:] y = sc0['rf_displacement_deg'][:].T rf_conditions = [ ut.k_and(~np.isnan(X[:, 0]), ~np.isnan(y[:, 0])), sqerror < 0.75, sigma > 3.3, pval[ikey] < 0.1 ] lkat = np.ones((X.shape[0], ), dtype='bool') for cond in rf_conditions: lkat_new = (lkat & cond) if lkat_new.sum() >= 5: lkat = lkat_new.copy() linreg = sklearn.linear_model.LinearRegression().fit( X[lkat], y[lkat]) displacement[ikey] = np.zeros_like(y) displacement[ikey][~np.isnan(X[:, 0])] = linreg.predict( X[~np.isnan(X[:, 0])]) return tuning, uparam, displacement, pval
np.squeeze(csd_fast_phase[ci, :, :]).T, np.squeeze(csd_fast_phase[cj, :, :]).T) plv_csd[ci, cj, :] = res_csd plv_csd[cj, ci, :] = res_csd res_lfp = plv( np.squeeze(lfp_fast_phase[ci, :, :]).T, np.squeeze(lfp_fast_phase[cj, :, :]).T) plv_lfp[ci, cj, :] = res_lfp plv_lfp[cj, ci, :] = res_lfp # %% Visualize PLV briefly plt.figure(figsize=(12, 6)) plt.subplot(121) plt.plot(gpcsd_model.t_pred.squeeze(), plv_csd.reshape((24 * 24, -1)).T) plt.plot(gpcsd_model.t_pred.squeeze(), np.nanmean(plv_csd.reshape((24 * 24, -1)), 0), 'k', linewidth=3) plt.subplot(122) plt.plot(gpcsd_model.t_pred.squeeze(), plv_lfp.reshape((24 * 24, -1)).T) plt.plot(gpcsd_model.t_pred.squeeze(), np.nanmean(plv_lfp.reshape((24 * 24, -1)), 0), 'k', linewidth=3) # %% Save phases at time point index 350 for Matlab analysis scipy.io.savemat( '%s/results/csd_lfp_filt_phases_%s.mat' % (root_path, probe_name), { 'csd': csd_fast_phase[:, 350, :], 'lfp': lfp_fast_phase[:, 350, :] })
def precompute_rotation_maps(self, rotations=None): """ Compute the averaged spectrum on the star for a given temperature map and for a given rotation Args: rotations (float) : [N_phases x 2] giving [longitude, latitude] in degrees for each phase Returns: None """ if (rotations is None): print("Use some angles for the rotations") return self.n_phases = rotations.shape[0] self.avg_mu = [None] * self.n_phases self.avg_v = [None] * self.n_phases self.velocity = [None] * self.n_phases self.n_pixel_unique = [None] * self.n_phases self.n_pixels = [None] * self.n_phases self.pixel_unique = [None] * self.n_phases for loop in range(self.n_phases): mu_pixel = np.zeros_like(self.mu_angle) v_pixel = np.zeros_like(self.vel_projection) pixel_map = self.projector.projmap(self.indices, self.f_vec2pix, rot=rotations[loop,:])[:,0:int(self.npix/2)] pixel_unique = np.unique(pixel_map[np.isfinite(pixel_map)]) for j in range(len(pixel_unique)): ind = np.where(pixel_map == pixel_unique[j]) if (np.all(np.isfinite(self.mu_angle[ind[0],ind[1]]))): if (self.mu_angle[ind[0],ind[1]].size == 0): mu_pixel[ind[0],ind[1]] = 0.0 v_pixel[ind[0],ind[1]] = 0.0 else: if (self.clv): value = np.nanmean(self.mu_angle[ind[0],ind[1]]) else: value = 1.0 mu_pixel[ind[0],ind[1]] = value value = np.nanmean(self.vel_projection[ind[0],ind[1]]) v_pixel[ind[0],ind[1]] = value else: mu_pixel[ind[0],ind[1]] = 0.0 v_pixel[ind[0],ind[1]] = 0.0 self.n_pixel_unique[loop] = len(pixel_unique) self.avg_mu[loop] = np.zeros(self.n_pixel_unique[loop]) self.avg_v[loop] = np.zeros(self.n_pixel_unique[loop]) self.velocity[loop] = np.zeros(self.n_pixel_unique[loop]) self.n_pixels[loop] = np.zeros(self.n_pixel_unique[loop], dtype='int') self.pixel_unique[loop] = pixel_unique.astype('int') for i in range(len(pixel_unique)): ind = np.where(pixel_map == pixel_unique[i]) self.n_pixels[loop][i] = len(ind[0]) self.avg_mu[loop][i] = np.unique(mu_pixel[ind[0], ind[1]]) self.avg_v[loop][i] = np.unique(v_pixel[ind[0], ind[1]]) self.velocity[loop][i] = self.avg_mu[loop][i] * self.avg_v[loop][i]
print(log_iw.shape) psis_lw, K_hat_stan = psislw(log_iw.T) K_hat_stan_advi_list[j, n] = K_hat_stan print(psis_lw.shape) print('K hat statistic for Stan ADVI:') print(K_hat_stan) ###################### Plotting L2 norm here ################################# plt.figure() plt.plot(stan_vb_w[:, 0], stan_vb_w[:, 1], 'mo', label='STAN-ADVI') plt.savefig('vb_w_samples_mf.pdf') np.save('K_hat_linear_' + datatype + '_' + algo_name + '_' + str(N) + 'N', K_hat_stan_advi_list) plt.figure() plt.plot(K_list, np.nanmean(K_hat_stan_advi_list, axis=1), 'r-', alpha=1) plt.plot(K_list, np.nanmin(K_hat_stan_advi_list, axis=1), 'r-', alpha=0.5) plt.plot(K_list, np.nanmax(K_hat_stan_advi_list, axis=1), 'r-', alpha=0.5) plt.xlabel('Dimensions') plt.ylabel('K-hat') np.save( 'K_hat_linear_' + datatype + '_' + algo_name + '_' + str(N) + 'N' + '_samples_' + str(gradsamples), K_hat_stan_advi_list) #plt.ylim((0,5)) plt.legend() plt.savefig('Linear_Regression_K_hat_vs_D_' + datatype + '_' + algo_name + '_' + str(N) + 'N.pdf')
def fit_weights_and_save(weights_file,ca_data_file='rs_vm_denoise_200605.npy',opto_silencing_data_file='vip_halo_data_for_sim.npy',opto_activation_data_file='vip_chrimson_data_for_sim.npy',constrain_wts=None,allow_var=True,fit_s02=True,constrain_isn=True,tv=False,l2_penalty=0.01,init_noise=0.1,init_W_from_lsq=False,scale_init_by=1,init_W_from_file=False,init_file=None,correct_Eta=False,init_Eta_with_s02=False,init_Eta12_with_dYY=False,use_opto_transforms=False): nsize,ncontrast = 6,6 npfile = np.load(ca_data_file,allow_pickle=True)[()]#,{'rs':rs,'rs_denoise':rs_denoise},allow_pickle=True) rs = npfile['rs'] #rs_denoise = npfile['rs_denoise'] nsize,ncontrast,ndir = 6,6,8 #ori_dirs = [[0,4],[2,6]] #[[0,4],[1,3,5,7],[2,6]] ori_dirs = [[0,1,2,3,4,5,6,7]] nT = len(ori_dirs) nS = len(rs[0]) def sum_to_1(r): R = r.reshape((r.shape[0],-1)) #R = R/np.nansum(R[:,~np.isnan(R.sum(0))],axis=1)[:,np.newaxis] R = R/np.nansum(R,axis=1)[:,np.newaxis] # changed 8/28 return R def norm_to_mean(r): R = r.reshape((r.shape[0],-1)) R = R/np.nanmean(R[:,~np.isnan(R.sum(0))],axis=1)[:,np.newaxis] return R Rs = [[None,None] for i in range(len(rs))] Rso = [[[None for iT in range(nT)] for iS in range(nS)] for icelltype in range(len(rs))] rso = [[[None for iT in range(nT)] for iS in range(nS)] for icelltype in range(len(rs))] for iR,r in enumerate(rs):#rs_denoise): print(iR) for ialign in range(nS): #Rs[iR][ialign] = r[ialign][:,:nsize,:] #sm = np.nanmean(np.nansum(np.nansum(Rs[iR][ialign],1),1)) #Rs[iR][ialign] = Rs[iR][ialign]/sm Rs[iR][ialign] = sum_to_1(r[ialign][:,:nsize,:]) # Rs[iR][ialign] = von_mises_denoise(Rs[iR][ialign].reshape((-1,nsize,ncontrast,ndir))) kernel = np.ones((1,2,2)) kernel = kernel/kernel.sum() for iR,r in enumerate(rs): for ialign in range(nS): for iori in range(nT): Rso[iR][ialign][iori] = np.nanmean(Rs[iR][ialign].reshape((-1,nsize,ncontrast,ndir))[:,:,:,ori_dirs[iori]],-1) Rso[iR][ialign][iori][:,:,0] = np.nanmean(Rso[iR][ialign][iori][:,:,0],1)[:,np.newaxis] # average 0 contrast values Rso[iR][ialign][iori][:,1:,1:] = ssi.convolve(Rso[iR][ialign][iori],kernel,'valid') Rso[iR][ialign][iori] = Rso[iR][ialign][iori].reshape(Rso[iR][ialign][iori].shape[0],-1) #Rso[iR][ialign][iori] = Rso[iR][ialign][iori]/np.nanmean(Rso[iR][ialign][iori],-1)[:,np.newaxis] def set_bound(bd,code,val=0): # set bounds to 0 where 0s occur in 'code' for iitem in range(len(bd)): bd[iitem][code[iitem]] = val nN = 36 nS = 2 nP = 2 nT = 1 nQ = 4 # code for bounds: 0 , constrained to 0 # +/-1 , constrained to +/-1 # 1.5, constrained to [0,1] # 2 , constrained to [0,inf) # -2 , constrained to (-inf,0] # 3 , unconstrained Wmx_bounds = 3*np.ones((nP,nQ),dtype=int) Wmx_bounds[0,1] = 0 # SSTs don't receive L4 input if allow_var: Wsx_bounds = 3*np.ones(Wmx_bounds.shape) #Wmx_bounds.copy()*0 #np.zeros_like(Wmx_bounds) Wsx_bounds[0,1] = 0 else: Wsx_bounds = np.zeros(Wmx_bounds.shape) #Wmx_bounds.copy()*0 #np.zeros_like(Wmx_bounds) Wmy_bounds = 3*np.ones((nQ,nQ),dtype=int) Wmy_bounds[0,:] = 2 # PCs are excitatory Wmy_bounds[1:,:] = -2 # all the cell types except PCs are inhibitory Wmy_bounds[1,1] = 0 # SSTs don't inhibit themselves # Wmy_bounds[3,1] = 0 # PVs are allowed to inhibit SSTs, consistent with Hillel's unpublished results, but not consistent with Pfeffer et al. Wmy_bounds[2,0] = 0 # VIPs don't inhibit L2/3 PCs. According to Pfeffer et al., only L5 PCs were found to get VIP inhibition if allow_var: Wsy_bounds = 3*np.ones(Wmy_bounds.shape) #Wmy_bounds.copy()*0 #np.zeros_like(Wmy_bounds) Wsy_bounds[1,1] = 0 Wsy_bounds[3,1] = 0 Wsy_bounds[2,0] = 0 else: Wsy_bounds = np.zeros(Wmy_bounds.shape) #Wmy_bounds.copy()*0 #np.zeros_like(Wmy_bounds) if not constrain_wts is None: for wt in constrain_wts: Wmy_bounds[wt[0],wt[1]] = 0 Wsy_bounds[wt[0],wt[1]] = 0 def tile_nS_nT_nN(kernel): row = np.concatenate([kernel for idim in range(nS*nT)],axis=0)[np.newaxis,:] tiled = np.concatenate([row for irow in range(nN)],axis=0) return tiled if fit_s02: s02_bounds = 2*np.ones((nQ,)) # permitting noise as a free parameter else: s02_bounds = np.ones((nQ,)) k_bounds = 1.5*np.ones((nQ*(nS-1),)) kappa_bounds = np.ones((1,)) # kappa_bounds = 2*np.ones((1,)) T_bounds = 1.5*np.ones((nQ*(nT-1),)) X_bounds = tile_nS_nT_nN(np.array([2,1])) # X_bounds = np.array([np.array([2,1,2,1])]*nN) Xp_bounds = tile_nS_nT_nN(np.array([3,1])) # Xp_bounds = np.array([np.array([3,1,3,1])]*nN) # Y_bounds = tile_nS_nT_nN(2*np.ones((nQ,))) # # Y_bounds = 2*np.ones((nN,nT*nS*nQ)) Eta_bounds = tile_nS_nT_nN(3*np.ones((nQ,))) # Eta_bounds = 3*np.ones((nN,nT*nS*nQ)) if allow_var: Xi_bounds = tile_nS_nT_nN(3*np.ones((nQ,))) else: Xi_bounds = tile_nS_nT_nN(np.zeros((nQ,))) # Xi_bounds = 3*np.ones((nN,nT*nS*nQ)) h1_bounds = -2*np.ones((1,)) h2_bounds = 2*np.ones((1,)) # In[8]: # shapes = [(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nQ,),(nQ,),(1,),(nN,nS*nP),(nN,nS*nQ),(nN,nS*nQ),(nN,nS*nQ)] shapes = [(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nQ,),(nQ*(nS-1),),(1,),(nQ*(nT-1),),(nN,nT*nS*nP),(nN,nT*nS*nP),(nN,nT*nS*nQ),(nN,nT*nS*nQ),(1,),(1,),(nN,nT*nS*nQ),(nN,nT*nS*nQ)] print('size of shapes: '+str(np.sum([np.prod(shp) for shp in shapes]))) # Wmx, Wmy, Wsx, Wsy, s02, k, kappa,T, XX, XXp, Eta, Xi, h1, h2, Eta1, Eta2 lb = [-np.inf*np.ones(shp) for shp in shapes] ub = [np.inf*np.ones(shp) for shp in shapes] bdlist = [Wmx_bounds,Wmy_bounds,Wsx_bounds,Wsy_bounds,s02_bounds,k_bounds,kappa_bounds,T_bounds,X_bounds,Xp_bounds,Eta_bounds,Xi_bounds,h1_bounds,h2_bounds,Eta_bounds,Eta_bounds] set_bound(lb,[bd==0 for bd in bdlist],val=0) set_bound(ub,[bd==0 for bd in bdlist],val=0) set_bound(lb,[bd==2 for bd in bdlist],val=0) set_bound(ub,[bd==-2 for bd in bdlist],val=0) set_bound(lb,[bd==1 for bd in bdlist],val=1) set_bound(ub,[bd==1 for bd in bdlist],val=1) set_bound(lb,[bd==1.5 for bd in bdlist],val=0) set_bound(ub,[bd==1.5 for bd in bdlist],val=1) set_bound(lb,[bd==-1 for bd in bdlist],val=-1) set_bound(ub,[bd==-1 for bd in bdlist],val=-1) # for bd in [lb,ub]: # for ind in [2,3]: # bd[ind][:,1] = 0 # temporary for no variation expt. # lb[2] = np.zeros_like(lb[2]) # lb[3] = np.zeros_like(lb[3]) # lb[4] = np.ones_like(lb[4]) # lb[5] = np.zeros_like(lb[5]) # ub[2] = np.zeros_like(ub[2]) # ub[3] = np.zeros_like(ub[3]) # ub[4] = np.ones_like(ub[4]) # ub[5] = np.ones_like(ub[5]) # temporary for no variation expt. lb = np.concatenate([a.flatten() for a in lb]) ub = np.concatenate([b.flatten() for b in ub]) bounds = [(a,b) for a,b in zip(lb,ub)] # In[10]: nS = 2 print('nT: '+str(nT)) ndims = 5 ncelltypes = 5 Yhat = [[None for iT in range(nT)] for iS in range(nS)] Xhat = [[None for iT in range(nT)] for iS in range(nS)] Ypc_list = [[None for iT in range(nT)] for iS in range(nS)] Xpc_list = [[None for iT in range(nT)] for iS in range(nS)] mx = [None for iS in range(nS)] for iS in range(nS): mx[iS] = np.zeros((ncelltypes,)) yy = [None for icelltype in range(ncelltypes)] for icelltype in range(ncelltypes): yy[icelltype] = np.nanmean(Rso[icelltype][iS][0],0) mx[iS][icelltype] = np.nanmax(yy[icelltype]) for iT in range(nT): y = [np.nanmean(Rso[icelltype][iS][iT],axis=0)[:,np.newaxis]/mx[iS][icelltype] for icelltype in range(1,ncelltypes)] Ypc_list[iS][iT] = [None for icelltype in range(1,ncelltypes)] for icelltype in range(1,ncelltypes): rss = Rso[icelltype][iS][iT].copy()#/mx[iS][icelltype] #.reshape(Rs[icelltype][ialign].shape[0],-1) #rss = Rso[icelltype][iS][iT].copy() #.reshape(Rs[icelltype][ialign].shape[0],-1) rss = rss[np.isnan(rss).sum(1)==0] # print(rss.max()) # rss[rss<0] = 0 # rss = rss[np.random.randn(rss.shape[0])>0] try: u,s,v = np.linalg.svd(rss-np.mean(rss,0)[np.newaxis]) Ypc_list[iS][iT][icelltype-1] = [(s[idim],v[idim]) for idim in range(ndims)] # print('yep on Y') # print(np.min(np.sum(rs[icelltype][iS][iT],axis=1))) except: # print('nope on Y') print(np.mean(np.isnan(rss))) print(np.min(np.sum(rs[icelltype][iS][iT],axis=1))) Yhat[iS][iT] = np.concatenate(y,axis=1) # x = sim_utils.columnize(Rso[0][iS][iT])[:,np.newaxis] icelltype = 0 #x = np.nanmean(Rso[icelltype][iS][iT],0)[:,np.newaxis]#/mx[iS][icelltype] x = np.nanmean(Rso[icelltype][iS][iT],0)[:,np.newaxis]/mx[iS][icelltype] # opto_column = np.concatenate((np.zeros((nN,)),np.zeros((nNO/2,)),np.ones((nNO/2,))),axis=0)[:,np.newaxis] Xhat[iS][iT] = np.concatenate((x,np.ones_like(x)),axis=1) # Xhat[iS][iT] = np.concatenate((x,np.ones_like(x),opto_column),axis=1) icelltype = 0 #rss = Rso[icelltype][iS][iT].copy()/mx[iS][icelltype] rss = Rso[icelltype][iS][iT].copy() rss = rss[np.isnan(rss).sum(1)==0] # try: u,s,v = np.linalg.svd(rss-rss.mean(0)[np.newaxis]) Xpc_list[iS][iT] = [None for iinput in range(2)] Xpc_list[iS][iT][0] = [(s[idim],v[idim]) for idim in range(ndims)] Xpc_list[iS][iT][1] = [(0,np.zeros((Xhat[0][0].shape[0],))) for idim in range(ndims)] # except: # print('nope on X') # print(np.mean(np.isnan(rss))) # print(np.min(np.sum(Rso[icelltype][iS][iT],axis=1))) nN,nP = Xhat[0][0].shape print('nP: '+str(nP)) nQ = Yhat[0][0].shape[1] # In[11]: def compute_f_(Eta,Xi,s02): return sim_utils.f_miller_troyer(Eta,Xi**2+np.concatenate([s02 for ipixel in range(nS*nT)])) def compute_fprime_m_(Eta,Xi,s02): return sim_utils.fprime_miller_troyer(Eta,Xi**2+np.concatenate([s02 for ipixel in range(nS*nT)]))*Xi def compute_fprime_s_(Eta,Xi,s02): s2 = Xi**2+np.concatenate((s02,s02),axis=0) return sim_utils.fprime_s_miller_troyer(Eta,s2)*(Xi/s2) def sorted_r_eigs(w): drW,prW = np.linalg.eig(w) srtinds = np.argsort(drW) return drW[srtinds],prW[:,srtinds] # In[12]: # 0.Wmx, 1.Wmy, 2.Wsx, 3.Wsy, 4.s02,5.K, 6.kappa,7.T,8.XX, 9.XXp, 10.Eta, 11.Xi, 12.h1, 13.h2, 14.Eta1, 15.Eta2 shapes = [(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nQ,),(nQ*(nS-1),),(1,),(nQ*(nT-1),),(nN,nT*nS*nP),(nN,nT*nS*nP),(nN,nT*nS*nQ),(nN,nT*nS*nQ),(1,),(1,),(nN,nT*nS*nQ),(nN,nT*nS*nQ)] print('size of shapes: '+str(np.sum([np.prod(shp) for shp in shapes]))) import calnet.fitting_spatial_feature import sim_utils YYhat = calnet.utils.flatten_nested_list_of_2d_arrays(Yhat) XXhat = calnet.utils.flatten_nested_list_of_2d_arrays(Xhat) opto_dict = np.load(opto_silencing_data_file,allow_pickle=True)[()] Yhat_opto = opto_dict['Yhat_opto'] Yhat_opto = np.nanmean(np.reshape(Yhat_opto,(nN,2,nS,2,nQ)),3).reshape((nN*2,-1)) Yhat_opto = Yhat_opto/Yhat_opto[0::2].max(0)[np.newaxis,:] print(Yhat_opto.shape) h_opto = opto_dict['h_opto'] #dYY1 = Yhat_opto[1::2]-Yhat_opto[0::2] YYhat_halo = Yhat_opto.reshape((nN,2,-1)) opto_transform1 = calnet.utils.fit_opto_transform(YYhat_halo) opto_transform1.res[:,[0,2,3,4,6,7]] = 0 dYY1 = opto_transform1.transform(YYhat) - YYhat #YYhat_halo_sim = calnet.utils.simulate_opto_effect(YYhat,YYhat_halo) #dYY1 = YYhat_halo_sim[:,1,:] - YYhat_halo_sim[:,0,:] def overwrite_plus_n(arr,to_overwrite,n): arr[:,to_overwrite] = arr[:,int(to_overwrite+n)] return arr for to_overwrite in [1,2]: n = 4 dYY1,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res \ = [overwrite_plus_n(x,to_overwrite,n) for x in \ [dYY1,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res]] for to_overwrite in [7]: n = -4 dYY1,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res \ = [overwrite_plus_n(x,to_overwrite,n) for x in \ [dYY1,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res]] #for to_overwrite in [1,2]: # dYY1[:,to_overwrite] = dYY1[:,to_overwrite+4] #for to_overwrite in [7]: # dYY1[:,to_overwrite] = dYY1[:,to_overwrite-4] #Yhat_opto = opto_dict['Yhat_opto'] #for iS in range(nS): # mx = np.zeros((nQ,)) # for iQ in range(nQ): # slicer = slice(nQ*nT*iS+iQ,nQ*nT*(1+iS),nQ) # mx[iQ] = np.nanmax(Yhat_opto[0::2][:,slicer]) # Yhat_opto[:,slicer] = Yhat_opto[:,slicer]/mx[iQ] ##Yhat_opto = Yhat_opto/Yhat_opto[0::2].max(0)[np.newaxis,:] #print(Yhat_opto.shape) #h_opto = opto_dict['h_opto'] #dYY1 = Yhat_opto[1::2]-Yhat_opto[0::2] #for to_overwrite in [1,2,5,6]: # overwrite sst and vip with off-centered values # dYY1[:,to_overwrite] = dYY1[:,to_overwrite+8] #for to_overwrite in [11,15]: # dYY1[:,to_overwrite] = np.nan #dYY1[:,to_overwrite-8] opto_dict = np.load(opto_activation_data_file,allow_pickle=True)[()] Yhat_opto = opto_dict['Yhat_opto'] Yhat_opto = np.nanmean(np.reshape(Yhat_opto,(nN,2,nS,2,nQ)),3).reshape((nN*2,-1)) Yhat_opto = Yhat_opto/Yhat_opto[0::2].max(0)[np.newaxis,:] print(Yhat_opto.shape) h_opto = opto_dict['h_opto'] #dYY2 = Yhat_opto[1::2]-Yhat_opto[0::2] YYhat_chrimson = Yhat_opto.reshape((nN,2,-1)) opto_transform2 = calnet.utils.fit_opto_transform(YYhat_chrimson) dYY2 = opto_transform2.transform(YYhat) - YYhat #YYhat_chrimson_sim = calnet.utils.simulate_opto_effect(YYhat,YYhat_chrimson) #dYY2 = YYhat_chrimson_sim[:,1,:] - YYhat_chrimson_sim[:,0,:] #Yhat_opto = opto_dict['Yhat_opto'] #for iS in range(nS): # mx = np.zeros((nQ,)) # for iQ in range(nQ): # slicer = slice(nQ*nT*iS+iQ,nQ*nT*(1+iS),nQ) # mx[iQ] = np.nanmax(Yhat_opto[0::2][:,slicer]) # Yhat_opto[:,slicer] = Yhat_opto[:,slicer]/mx[iQ] ##Yhat_opto = Yhat_opto/Yhat_opto[0::2].max(0)[np.newaxis,:] #print(Yhat_opto.shape) #h_opto = opto_dict['h_opto'] #dYY2 = Yhat_opto[1::2]-Yhat_opto[0::2] print('dYY1 mean: %03f'%np.nanmean(np.abs(dYY1))) print('dYY2 mean: %03f'%np.nanmean(np.abs(dYY2))) dYY = np.concatenate((dYY1,dYY2),axis=0) titles = ['VIP silencing','VIP activation'] for itype in [0,1,2,3]: plt.figure(figsize=(5,2.5)) for iyy,dyy in enumerate([dYY1,dYY2]): plt.subplot(1,2,iyy+1) if np.sum(np.isnan(dyy[:,itype]))==0: sca.scatter_size_contrast(YYhat[:,itype],YYhat[:,itype]+dyy[:,itype],nsize=6,ncontrast=6)#,mn=0) plt.title(titles[iyy]) plt.xlabel('cell type %d event rate, \n light off'%itype) plt.ylabel('cell type %d event rate, \n light on'%itype) ut.erase_top_right() plt.tight_layout() ut.mkdir('figures') plt.savefig('figures/scatter_light_on_light_off_target_celltype_%d.eps'%itype) opto_mask = ~np.isnan(dYY) #dYY[nN:][~opto_mask[nN:]] = -dYY[:nN][~opto_mask[nN:]] print('mean of opto_mask: '+str(opto_mask.mean())) #dYY[~opto_mask] = 0 def zero_nans(arr): arr[np.isnan(arr)] = 0 return arr #dYY,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res,\ # opto_transform2.slope,opto_transform2.intercept,opto_transform2.res\ # = [zero_nans(x) for x in \ # [dYY,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res,\ # opto_transform2.slope,opto_transform2.intercept,opto_transform2.res]] dYY = zero_nans(dYY) to_adjust = np.logical_or(np.isnan(opto_transform2.slope[0]),np.isnan(opto_transform2.intercept[0])) opto_transform2.slope[:,to_adjust] = 1/opto_transform1.slope[:,to_adjust] opto_transform2.intercept[:,to_adjust] = -opto_transform1.intercept[:,to_adjust]/opto_transform1.slope[:,to_adjust] opto_transform2.res[:,to_adjust] = -opto_transform1.res[:,to_adjust]/opto_transform1.slope[:,to_adjust] np.save('/Users/dan/Documents/notebooks/mossing-PC/shared_data/calnet_data/dYY.npy',dYY) from importlib import reload reload(calnet) #reload(calnet.fitting_spatial_feature_opto_nonlinear) reload(sim_utils) # reload(calnet.fitting_spatial_feature) # W0list = [np.ones(shp) for shp in shapes] wt_dict = {} wt_dict['X'] = 1 wt_dict['Y'] = 15 wt_dict['Eta'] = 10 # 1 # wt_dict['Xi'] = 0.1 wt_dict['stims'] = np.ones((nN,1)) #(np.arange(30)/30)[:,np.newaxis]**1 # wt_dict['barrier'] = 0. #30.0 #0.1 wt_dict['opto'] = 1e-1#1e1 wt_dict['isn'] = 3 wt_dict['tv'] = 1 wt_dict['stimsOpto'] = 0.6*np.ones((nN,1)) wt_dict['stimsOpto'][0::6] = 3 wt_dict['celltypesOpto'] = 0.67*np.ones((1,nQ*nS*nT)) wt_dict['celltypesOpto'][0,0::nQ] = 2 wt_dict['dirOpto'] = np.array((1,0.5)) wt_dict['dYY'] = 1#1000 wt_dict['Eta12'] = 1 wt_dict['coupling'] = 1 np.save('XXYYhat.npy',{'YYhat':YYhat,'XXhat':XXhat,'rs':rs,'Rs':Rs,'Rso':Rso,'Ypc_list':Ypc_list,'Xpc_list':Xpc_list}) Eta0 = invert_f_mt(YYhat) Eta10 = invert_f_mt(YYhat + dYY[:nN]) Eta20 = invert_f_mt(YYhat + dYY[nN:]) print('mean Eta1 diff: '+str(np.mean(np.abs(Eta0-Eta10)))) print('mean Eta2 diff: '+str(np.mean(np.abs(Eta0-Eta20)))) ntries = 1 nhyper = 1 dt = 1e-1 niter = int(np.round(10/dt)) #int(1e4) perturbation_size = 5e-2 # learning_rate = 1e-4 # 1e-5 #np.linspace(3e-4,1e-3,niter+1) # 1e-5 #l2_penalty = 0.1 Wt = [[None for itry in range(ntries)] for ihyper in range(nhyper)] loss = np.zeros((nhyper,ntries)) is_neg = np.array([b[1] for b in bounds])==0 counter = 0 negatize = [np.zeros(shp,dtype='bool') for shp in shapes] print(shapes) for ishp,shp in enumerate(shapes): nel = np.prod(shp) negatize[ishp][:][is_neg[counter:counter+nel].reshape(shp)] = True counter = counter + nel for ihyper in range(nhyper): for itry in range(ntries): print((ihyper,itry)) W0list = [init_noise*(ihyper+1)*np.random.rand(*shp) for shp in shapes] print('size of shapes: '+str(np.sum([np.prod(shp) for shp in shapes]))) print('size of w0: '+str(np.sum([np.size(x) for x in W0list]))) print('len(W0list) : '+str(len(W0list))) counter = 0 for ishp,shp in enumerate(shapes): W0list[ishp][negatize[ishp]] = -W0list[ishp][negatize[ishp]] W0list[4] = np.ones(shapes[5]) # s02 W0list[5] = np.ones(shapes[5]) # K W0list[6] = np.ones(shapes[6]) # kappa W0list[7] = np.ones(shapes[7]) # T W0list[8] = np.concatenate(Xhat,axis=1) #XX W0list[9] = np.zeros_like(W0list[8]) #XXp W0list[10] = Eta0.copy() #np.zeros(shapes[10]) #Eta W0list[11] = np.zeros(shapes[11]) #Xi W0list[14] = Eta10.copy() # Eta1 W0list[15] = Eta20.copy() # Eta2 #[Wmx,Wmy,Wsx,Wsy,s02,k,kappa,T,XX,XXp,Eta,Xi] # W0list = Wstar_dict['as_list'].copy() # W0list[1][1,0] = -1.5 # W0list[1][3,0] = -1.5 if init_W_from_lsq: W0list[0],W0list[1] = initialize_W(Xhat,Yhat,scale_by=scale_init_by) for ivar in range(0,2): W0list[ivar] = W0list[ivar] + init_noise*np.random.randn(*W0list[ivar].shape) if constrain_isn: W0list[1][0,0] = 3 W0list[1][0,3] = 5 W0list[1][3,0] = -5 W0list[1][3,3] = -5 #if constrain_isn: # W0list[1][0,0] = 2 # W0list[1][0,3] = 2 # W0list[1][3,0] = -2 # W0list[1][3,3] = -2 #if wt_dict['coupling'] > 0: # W0list[1][1,0] = -1 if init_W_from_file: npyfile = np.load(init_file,allow_pickle=True)[()] W0list = npyfile['as_list'] if W0list[8].size == nN*nS*2*nP: W0list[7] = np.array(()) W0list[1][1,0] = W0list[1][1,0] W0list[8] = np.nanmean(W0list[8].reshape((nN,nS,2,nP)),2).flatten() #XX W0list[9] = np.nanmean(W0list[9].reshape((nN,nS,2,nP)),2).flatten() #XXp W0list[10] = np.nanmean(W0list[10].reshape((nN,nS,2,nQ)),2).flatten() #Eta W0list[11] = np.nanmean(W0list[11].reshape((nN,nS,2,nQ)),2).flatten() #Xi if correct_Eta: W0list[10] = Eta0.copy() if len(W0list) < len(shapes): W0list = W0list[:-1] + [np.array(-0.5),np.array(1),Eta10.copy(),Eta20.copy()] # add h1,h2,Eta1,Eta2 if init_Eta_with_s02: s02 = W0list[4].copy() Eta0 = invert_f_mt_with_s02(YYhat,s02,nS=nS,nT=nT) Eta10 = invert_f_mt_with_s02(YYhat+dYY[:nN],s02,nS=nS,nT=nT) Eta20 = invert_f_mt_with_s02(YYhat+dYY[nN:],s02,nS=nS,nT=nT) W0list[10] = Eta0.copy() W0list[14] = Eta10.copy() W0list[15] = Eta20.copy() if init_Eta12_with_dYY: Eta0 = W0list[10].copy().reshape((nN,nQ*nS*nT)) Xi0 = W0list[11].copy().reshape((nN,nQ*nS*nT)) s020 = W0list[4].copy() YY0s = compute_f_(Eta0,Xi0,s020) this_YY1 = opto_transform1.transform(YY0s) this_YY2 = opto_transform2.transform(YY0s) Eta10 = invert_f_mt_with_s02(this_YY1,s020,nS=nS,nT=nT) Eta20 = invert_f_mt_with_s02(this_YY2,s020,nS=nS,nT=nT) W0list[14] = Eta10.copy() W0list[15] = Eta20.copy() YY10s = compute_f_(Eta10,Xi0,s020) YY20s = compute_f_(Eta20,Xi0,s020) titles = ['VIP silencing','VIP activation'] for itype in [0,1,2,3]: plt.figure(figsize=(5,2.5)) for iyy,yy in enumerate([YY10s,YY20s]): plt.subplot(1,2,iyy+1) if np.sum(np.isnan(yy[:,itype]))==0: sca.scatter_size_contrast(YY0s[:,itype],yy[:,itype],nsize=6,ncontrast=6)#,mn=0) plt.title(titles[iyy]) plt.xlabel('cell type %d event rate, \n light off'%itype) plt.ylabel('cell type %d event rate, \n light on'%itype) ut.erase_top_right() plt.tight_layout() ut.mkdir('figures') plt.savefig('figures/scatter_light_on_light_off_init_celltype_%d.eps'%itype) #if wt_dict['coupling'] > 0: # W0list[1][1,0] = W0list[1][1,0] - 1 for ivar in [0,1,4,5]: # Wmx, Wmy, s02, k W0list[ivar] = W0list[ivar] + init_noise*np.random.randn(*W0list[ivar].shape) # wt_dict['Xi'] = 10 # wt_dict['Eta'] = 10 print('size of bounds: '+str(np.sum([np.size(x) for x in bdlist]))) print('size of w0: '+str(np.sum([np.size(x) for x in W0list]))) print('size of shapes: '+str(np.sum([np.prod(shp) for shp in shapes]))) Wt[ihyper][itry],loss[ihyper][itry],gr,hess,result = calnet.fitting_spatial_feature_opto_nonlinear.fit_W_sim(Xhat,Xpc_list,Yhat,Ypc_list,pop_rate_fn=sim_utils.f_miller_troyer,pop_deriv_fn=sim_utils.fprime_miller_troyer,neuron_rate_fn=sim_utils.evaluate_f_mt,W0list=W0list.copy(),bounds=bounds,niter=niter,wt_dict=wt_dict,l2_penalty=l2_penalty,compute_hessian=False,dt=dt,perturbation_size=perturbation_size,dYY=dYY,constrain_isn=constrain_isn,tv=tv,opto_mask=opto_mask,use_opto_transforms=use_opto_transforms,opto_transform1=opto_transform1,opto_transform2=opto_transform2) # Wt[ihyper][itry] = [w[-1] for w in Wt_temp] # loss[ihyper,itry] = loss_temp[-1] def parse_W(W): Wmx,Wmy,Wsx,Wsy,s02,K,kappa,T,XX,XXp,Eta,Xi,h1,h2,Eta1,Eta2 = W return Wmx,Wmy,Wsx,Wsy,s02,K,kappa,T,XX,XXp,Eta,Xi,h1,h2,Eta1,Eta2 itry = 0 Wmx,Wmy,Wsx,Wsy,s02,K,kappa,T,XX,XXp,Eta,Xi,h1,h2,Eta1,Eta2 = parse_W(Wt[0][0]) labels = ['Wmx','Wmy','Wsx','Wsy','s02','K','kappa','T','XX','XXp','Eta','Xi','h1','h2','Eta1','Eta2'] Wstar_dict = {} for i,label in enumerate(labels): Wstar_dict[label] = Wt[0][0][i] Wstar_dict['as_list'] = [Wmx,Wmy,Wsx,Wsy,s02,K,kappa,T,XX,XXp,Eta,Xi,h1,h2,Eta1,Eta2] Wstar_dict['loss'] = loss[0][0] Wstar_dict['wt_dict'] = wt_dict np.save(weights_file,Wstar_dict,allow_pickle=True)
def fit_weights_and_save(weights_file,ca_data_file='rs_sc_fg_pval_0_05_210410.npy',opto_silencing_data_file='vip_halo_data_for_sim.npy',opto_activation_data_file='vip_chrimson_data_for_sim.npy',constrain_wts=None,allow_var=True,multiout=True,multiout2=False,fit_s02=True,constrain_isn=True,tv=False,l2_penalty=0.01,l1_penalty=1.0,init_noise=0.1,init_W_from_lsq=False,scale_init_by=1,init_W_from_file=False,init_file=None,foldT=False,free_amplitude=False,correct_Eta=False,init_Eta_with_s02=False,no_halo_res=False,ignore_halo_vip=False,use_opto_transforms=False,norm_opto_transforms=False,nondim=False,fit_running=False,fit_non_running=True,fit_sc=True,fit_fg=False): nsize,ncontrast = 6,6 nrun = 2 nsize,ncontrast,ndir = 6,6,8 nstim_fg = 5 fit_both_running = (fit_non_running and fit_running) fit_both_stims = (fit_sc and fit_fg) if not fit_both_running: nrun = 1 if fit_non_running: irun = 0 elif fit_running: irun = 1 nsc = nrun*nsize*ncontrast*ndir nfg = nrun*nstim_fg*ndir npfile = np.load(ca_data_file,allow_pickle=True)[()]#,{'rs':rs},allow_pickle=True) # ,'rs_denoise':rs_denoise if fit_both_running: Rs_mean = npfile['Rs_mean_run'] Rs_cov = npfile['Rs_cov_run'] if not fit_both_stims: if fit_sc: Rs_mean,Rs_cov = get_Rs_slice(Rs_mean,Rs_cov,slice(None,nsc)) elif fit_fg: Rs_mean,Rs_cov = get_Rs_slice(Rs_mean,Rs_cov,slice(nsc,None)) else: Rs_mean = npfile['Rs_mean'][irun] Rs_cov = npfile['Rs_cov'][irun] if not fit_both_stims: if fit_sc: Rs_mean,Rs_cov = get_Rs_slice(Rs_mean,Rs_cov,slice(None,nsc)) elif fit_fg: Rs_mean,Rs_cov = get_Rs_slice(Rs_mean,Rs_cov,slice(nsc,None)) ori_dirs = [[0,4],[2,6]] #[[0,4],[1,3,5,7],[2,6]] ndims = 5 nT = len(ori_dirs) nS = len(Rs_mean[0]) def sum_to_1(r): R = r.reshape((r.shape[0],-1)) R = R/np.nansum(R[:,~np.isnan(R.sum(0))],axis=1)[:,np.newaxis] # changed 21/4/10 return R def norm_to_mean(r): R = r.reshape((r.shape[0],-1)) R = R/np.nanmean(R[:,~np.isnan(R.sum(0))],axis=1)[:,np.newaxis] return R def ori_avg(Rs,these_ori_dirs): if fit_sc: rs_sc = np.nanmean(Rs[:nsc].reshape((nrun,nsize,ncontrast,ndir))[:,:,:,these_ori_dirs],-1) rs_sc[:,1:,1:] = ssi.convolve(rs_sc,kernel,'valid') rs_sc = rs_sc.reshape((nrun*nsize*ncontrast)) if fit_fg: rs_fg = np.nanmean(Rs[nsc:].reshape((nrun,nstim_fg,ndir))[:,:,these_ori_dirs],-1) rs_fg = rs_fg.reshape((nrun*nstim_fg)) else: rs_fg = np.zeros((0,)) elif fit_fg: rs_sc = np.zeros((0,)) rs_fg = np.nanmean(Rs.reshape((nrun,nstim_fg,ndir))[:,:,these_ori_dirs],-1) rs_fg = rs_fg.reshape((nrun*nstim_fg)) Rso = np.concatenate((rs_sc,rs_fg)) return Rso Rso_mean = [[[None for iT in range(nT)] for iS in range(nS)] for icelltype in range(len(Rs_mean))] Rso_cov = [[[[[None,None] for idim in range(ndims)] for iT in range(nT)] for iS in range(nS)] for icelltype in range(len(Rs_mean))] kernel = np.ones((1,2,2)) kernel = kernel/kernel.sum() for iR,r in enumerate(Rs_mean): for ialign in range(nS): for iori in range(nT): Rso_mean[iR][ialign][iori] = ori_avg(Rs_mean[iR][ialign],ori_dirs[iori]) for idim in range(ndims): Rso_cov[iR][ialign][iori][idim][0] = Rs_cov[iR][ialign][idim][0] Rso_cov[iR][ialign][iori][idim][1] = ori_avg(Rs_cov[iR][ialign][idim][1],ori_dirs[iori]) def set_bound(bd,code,val=0): # set bounds to 0 where 0s occur in 'code' for iitem in range(len(bd)): bd[iitem][code[iitem]] = val nN = (36*fit_sc + 5*fit_fg)*(1 + fit_both_running) nS = 2 nP = 2 + fit_both_running nT = 2 nQ = 4 ndims = 5 ncelltypes = 5 #print('foldT: %d'%foldT) if foldT: Yhat = [None for iS in range(nS)] Xhat = [None for iS in range(nS)] Ypc_list = [None for iS in range(nS)] Xpc_list = [None for iS in range(nS)] print('have not written this yet') assert(True==False) else: Yhat = [[None for iT in range(nT)] for iS in range(nS)] Xhat = [[None for iT in range(nT)] for iS in range(nS)] Ypc_list = [[None for iT in range(nT)] for iS in range(nS)] Xpc_list = [[None for iT in range(nT)] for iS in range(nS)] for iS in range(nS): mx = np.zeros((ncelltypes,)) yy = [None for icelltype in range(ncelltypes)] for icelltype in range(ncelltypes): yy[icelltype] = np.concatenate(Rso_mean[icelltype][iS]) mx[icelltype] = np.nanmax(yy[icelltype]) for iT in range(nT): y = [Rso_mean[icelltype][iS][iT][:,np.newaxis]/mx[icelltype] for icelltype in range(1,ncelltypes)] Yhat[iS][iT] = np.concatenate(y,axis=1) Ypc_list[iS][iT] = [None for icelltype in range(1,ncelltypes)] for icelltype in range(1,ncelltypes): Ypc_list[iS][iT][icelltype-1] = [(this_dim[0]/mx[icelltype],this_dim[1]) for this_dim in Rso_cov[icelltype][iS][iT]] icelltype = 0 x = Rso_mean[icelltype][iS][iT][:,np.newaxis]/mx[icelltype] if fit_both_running: run_vector = np.zeros_like(x) if fit_both_stims: run_vector[nsize*ncontrast:2*nsize*ncontrast] = 1 run_vector[-nstim_fg:] = 1 else: run_vector[int(np.round(run_vector.shape[0]/2)):,:] = 1 else: run_vector = np.zeros((x.shape[0],0)) Xhat[iS][iT] = np.concatenate((x,np.ones_like(x),run_vector),axis=1) Xpc_list[iS][iT] = [None for iinput in range(2+fit_both_running)] Xpc_list[iS][iT][0] = [(this_dim[0]/mx[icelltype],this_dim[1]) for this_dim in Rso_cov[icelltype][iS][iT]] Xpc_list[iS][iT][1] = [(0,np.zeros((Xhat[0][0].shape[0],))) for idim in range(ndims)] if fit_both_running: Xpc_list[iS][iT][2] = [(0,np.zeros((Xhat[0][0].shape[0],))) for idim in range(ndims)] nN,nP = Xhat[0][0].shape nQ = Yhat[0][0].shape[1] # code for bounds: 0 , constrained to 0 # +/-1 , constrained to +/-1 # 1.5, constrained to [0,1] # -1.5, constrained to [-1,1] # 2 , constrained to [0,inf) # -2 , constrained to (-inf,0] # 3 , unconstrained W0x_bounds = 3*np.ones((nP,nQ),dtype=int) W0x_bounds[0,:] = 2 # L4 PCs are excitatory W0x_bounds[0,1] = 0 # SSTs don't receive L4 input if allow_var: if nondim: W1x_bounds = -1.5*np.ones(W0x_bounds.shape) #W0x_bounds.copy()*0 #np.zeros_like(W0x_bounds) else: W1x_bounds = 3*np.ones(W0x_bounds.shape) #W0x_bounds.copy()*0 #np.zeros_like(W0x_bounds) W1x_bounds[0,1] = 0 else: W1x_bounds = np.zeros(W0x_bounds.shape) #W0x_bounds.copy()*0 #np.zeros_like(W0x_bounds) W0y_bounds = 3*np.ones((nQ,nQ),dtype=int) W0y_bounds[0,:] = 2 # PCs are excitatory W0y_bounds[1:,:] = -2 # all the cell types except PCs are inhibitory W0y_bounds[1,1] = 0 # SSTs don't inhibit themselves # W0y_bounds[3,1] = 0 # PVs are allowed to inhibit SSTs, consistent with Hillel's unpublished results, but not consistent with Pfeffer et al. W0y_bounds[2,0] = 0 # VIPs don't inhibit L2/3 PCs. According to Pfeffer et al., only L5 PCs were found to get VIP inhibition W0y_bounds[2,2] = 0 # newly added: no VIP-VIP inhibition if not constrain_wts is None: for wt in constrain_wts: W0y_bounds[wt[0],wt[1]] = 0 W1y_bounds[wt[0],wt[1]] = 0 def tile_nS_nT_nN(kernel): row = np.concatenate([kernel for idim in range(nS*nT)],axis=0)[np.newaxis,:] tiled = np.concatenate([row for irow in range(nN)],axis=0) return tiled if fit_s02: s02_bounds = 2*np.ones((nQ,)) # permitting noise as a free parameter else: s02_bounds = np.ones((nQ,)) Kin0_bounds = 1.5*np.ones((nQ,)) kappa_bounds = np.ones((1,)) # kappa_bounds = 2*np.ones((1,)) Tin0_bounds = 1.5*np.ones((nQ,)) #T_bounds[2:4] = 1 # PV and VIP are constrained to have flat ori tuning #Tin0_bounds[1:4] = 1 # SST,VIP, and PV are constrained to have flat ori tuning if nondim: kt_factor = -1.5 else: kt_factor = 3 if allow_var: W1y_bounds = kt_factor*np.ones(W0y_bounds.shape) #W0y_bounds.copy()*0 #np.zeros_like(W0y_bounds) Kin1_bounds = kt_factor*np.ones(Kin0_bounds.shape) #W0y_bounds.copy()*0 #np.zeros_like(W0y_bounds) Tin1_bounds = kt_factor*np.ones(Tin0_bounds.shape) #W0y_bounds.copy()*0 #np.zeros_like(W0y_bounds) W1y_bounds[1,1] = 0 #W1y_bounds[3,1] = 0 W1y_bounds[2,0] = 0 W1y_bounds[2,2] = 0 # newly added: no VIP-VIP inhibition else: W1y_bounds = np.zeros(W0y_bounds.shape) #W0y_bounds.copy()*0 #np.zeros_like(W0y_bounds) Kin1_bounds = 0*np.ones(Kin0_bounds.shape) #W0y_bounds.copy()*0 #np.zeros_like(W0y_bounds) Tin1_bounds = 0*np.ones(Tin0_bounds.shape) #W0y_bounds.copy()*0 #np.zeros_like(W0y_bounds) if multiout: W2x_bounds = W1x_bounds.copy() W2y_bounds = W1y_bounds.copy() if multiout2: W3x_bounds = W1x_bounds.copy() W3y_bounds = W1y_bounds.copy() else: W3x_bounds = W1x_bounds.copy()*0 W3y_bounds = W1y_bounds.copy()*0 else: W2x_bounds = W1x_bounds.copy()*0 W2y_bounds = W1y_bounds.copy()*0 W3x_bounds = W1x_bounds.copy()*0 W3y_bounds = W1y_bounds.copy()*0 Kxout0_bounds = np.array((1.5,)+tuple(np.zeros((nP-1,)))) Txout0_bounds = Kxout0_bounds.copy() Kxout1_bounds = np.array((kt_factor,)+tuple(np.zeros((nP-1,)))) Txout1_bounds = Kxout1_bounds.copy() Kyout0_bounds = Kin0_bounds.copy() Tyout0_bounds = Tin0_bounds.copy() Kyout1_bounds = Kin1_bounds.copy() Tyout1_bounds = Tin1_bounds.copy() if fit_both_running: to_tile = Xhat[0][0][:,1:] to_tile = np.concatenate((2*np.ones((to_tile.shape[0],1)),to_tile),axis=1) X_bounds = np.tile(to_tile,(1,nS*nT)) else: X_bounds = tile_nS_nT_nN(np.array([2,1])) #print(X_bounds.shape) # X_bounds = np.array([np.array([2,1,2,1])]*nN) if fit_both_running: Xp_bounds = tile_nS_nT_nN(np.array([3,0,0])) # edited to set XXp to 0 for spont. term else: Xp_bounds = tile_nS_nT_nN(np.array([3,0])) # edited to set XXp to 0 for spont. term # Xp_bounds = np.array([np.array([3,1,3,1])]*nN) # Y_bounds = tile_nS_nT_nN(2*np.ones((nQ,))) # # Y_bounds = 2*np.ones((nN,nT*nS*nQ)) Eta_bounds = tile_nS_nT_nN(3*np.ones((nQ,))) # Eta_bounds = 3*np.ones((nN,nT*nS*nQ)) #if allow_var: # Xi_bounds = tile_nS_nT_nN(3*np.ones((nQ,))) #else: # Xi_bounds = tile_nS_nT_nN(np.zeros((nQ,))) Xi_bounds = tile_nS_nT_nN(3*np.ones((nQ,))) # temporarily allowing Xi even if W1 is not allowed # Xi_bounds = 3*np.ones((nN,nT*nS*nQ)) h1_bounds = -2*np.ones((1,)) h2_bounds = 2*np.ones((1,)) bl_bounds = 3*np.ones((nQ,)) if free_amplitude: amp_bounds = 2*np.ones((nT*nS*nQ,)) else: amp_bounds = 1*np.ones((nT*nS*nQ,)) # shapes = [(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nQ,),(nQ,),(1,),(nN,nS*nP),(nN,nS*nQ),(nN,nS*nQ),(nN,nS*nQ)] #shapes = [(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nQ,),(nQ*(nS-1),),(nQ*(nS-1),),(nQ*(nS-1),),(nQ*(nS-1),),(1,),(nQ*(nT-1),),(nQ*(nT-1),),(nQ*(nT-1),),(nQ*(nT-1),),(nN,nT*nS*nP),(nN,nT*nS*nP),(nN,nT*nS*nQ),(nN,nT*nS*nQ),(1,)] shapes1 = [(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nQ,),(nQ*(nS-1),),(nQ*(nS-1),),(nP*(nS-1),),(nQ*(nS-1),),(nP*(nS-1),),(nQ*(nS-1),),(1,),(nQ*(nT-1),),(nQ*(nT-1),),(nP*(nT-1),),(nQ*(nT-1),),(nP*(nT-1),),(nQ*(nT-1),),(1,),(1,),(nQ,),(nT*nS*nQ,)] shapes2 = [(nN,nT*nS*nP),(nN,nT*nS*nP),(nN,nT*nS*nQ),(nN,nT*nS*nQ)] # W0x, W0y, W1x, W1y, W2x, W2y, W3x, W3y, s02, k, kappa,T, XX, XXp, Eta, Xi #lb = [-np.inf*np.ones(shp) for shp in shapes] #ub = [np.inf*np.ones(shp) for shp in shapes] #bdlist = [W0x_bounds,W0y_bounds,W1x_bounds,W1y_bounds,W2x_bounds,W2y_bounds,W3x_bounds,W3y_bounds,s02_bounds,k0_bounds,k1_bounds,k2_bounds,k3_bounds,kappa_bounds,Tin0_bounds,Tin1_bounds,Tout0_bounds,Tout1_bounds,X_bounds,Xp_bounds,Eta_bounds,Xi_bounds,h_bounds] bd1list = [W0x_bounds,W0y_bounds,W1x_bounds,W1y_bounds,W2x_bounds,W2y_bounds,W3x_bounds,W3y_bounds,s02_bounds,Kin0_bounds,Kin1_bounds,Kxout0_bounds,Kyout0_bounds,Kxout1_bounds,Kyout1_bounds,kappa_bounds,Tin0_bounds,Tin1_bounds,Txout0_bounds,Tyout0_bounds,Txout1_bounds,Tyout1_bounds,h1_bounds,h2_bounds,bl_bounds,amp_bounds] bd2list = [X_bounds,Xp_bounds,Eta_bounds,Xi_bounds] lb1,ub1 = [[sgn*np.inf*np.ones(shp) for shp in shapes1] for sgn in [-1,1]] lb1,ub1 = calnet.utils.set_bounds_by_code(lb1,ub1,bd1list) lb2,ub2 = [[sgn*np.inf*np.ones(shp) for shp in shapes2] for sgn in [-1,1]] lb2,ub2 = calnet.utils.set_bounds_by_code(lb2,ub2,bd2list) lb1 = np.concatenate([a.flatten() for a in lb1]) ub1 = np.concatenate([b.flatten() for b in ub1]) lb2 = np.concatenate([a.flatten() for a in lb2]) ub2 = np.concatenate([b.flatten() for b in ub2]) bounds1 = [(a,b) for a,b in zip(lb1,ub1)] bounds2 = [(a,b) for a,b in zip(lb2,ub2)] def compute_f_(Eta,Xi,s02): return sim_utils.f_miller_troyer(Eta,Xi**2+np.concatenate([s02 for ipixel in range(nS*nT)])) def compute_fprime_m_(Eta,Xi,s02): return sim_utils.fprime_miller_troyer(Eta,Xi**2+np.concatenate([s02 for ipixel in range(nS*nT)]))*Xi def compute_fprime_s_(Eta,Xi,s02): s2 = Xi**2+np.concatenate((s02,s02),axis=0) return sim_utils.fprime_s_miller_troyer(Eta,s2)*(Xi/s2) def sorted_r_eigs(w): drW,prW = np.linalg.eig(w) srtinds = np.argsort(drW) return drW[srtinds],prW[:,srtinds] #0.W0x,1.W0y,2.W1x,3.W1y,4.W2x,5.W2y,6.W3x,7.W3y,8.s02,9.Kin0,10.Kin1,11.Kout0,12.Kout1,13.kappa,14.Tin0,15.Tin1,16.Txout0,Tyout0,17.Txout1,Tyout1,18.h1,19.h2,20.bl,21.amp #0.XX,1.XXp,2.Eta,3.Xi #shapes = [(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nQ,),(nQ*(nS-1),),(nQ*(nS-1),),(nQ*(nS-1),),(nQ*(nS-1),),(1,),(nQ*(nT-1),),(nQ*(nT-1),),(nQ*(nT-1),),(nQ*(nT-1),),(nN,nT*nS*nP),(nN,nT*nS*nP),(nN,nT*nS*nQ),(nN,nT*nS*nQ),(1,)] #shapes1 = [(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nQ,),(nQ*(nS-1),),(nQ*(nS-1),),(nQ*(nS-1),),(nQ*(nS-1),),(1,),(nQ*(nT-1),),(nQ*(nT-1),),(nQ*(nT-1),),(nQ*(nT-1),),(1,),(1,),(nQ,),(nT*nS*nQ,)] #shapes2 = [(nN,nT*nS*nP),(nN,nT*nS*nP),(nN,nT*nS*nQ),(nN,nT*nS*nQ)] import sim_utils YYhat = calnet.utils.flatten_nested_list_of_2d_arrays(Yhat) opto_dict = np.load(opto_silencing_data_file,allow_pickle=True)[()] Yhat_opto = opto_dict['Yhat_opto'] Yhat_opto = np.ones((nN*2,nQ*nS*nT)) #Yhat_opto = Yhat_opto.reshape((nN*2,-1)) Yhat_opto[0::12] = np.nanmean(Yhat_opto[0::12],axis=0)[np.newaxis] Yhat_opto[1::12] = np.nanmean(Yhat_opto[1::12],axis=0)[np.newaxis] Yhat_opto = Yhat_opto/np.nanmax(Yhat_opto[0::2],0)[np.newaxis,:] #print(Yhat_opto.shape) h_opto = np.zeros((nN*2,)) #h_opto = opto_dict['h_opto'] #dYY1 = Yhat_opto[1::2]-Yhat_opto[0::2] YYhat_halo = Yhat_opto.reshape((nN,2,-1)) opto_transform1 = calnet.utils.fit_opto_transform(YYhat_halo,norm01=norm_opto_transforms) if no_halo_res: opto_transform1.res[:,[0,2,3,4,6,7]] = 0 dYY1 = opto_transform1.transform(YYhat) - opto_transform1.preprocess(YYhat) #print('delta bias: %f'%dXX1[:,1].mean()) #YYhat_halo_sim = calnet.utils.simulate_opto_effect(YYhat,YYhat_halo) #dYY1 = YYhat_halo_sim[:,1,:] - YYhat_halo_sim[:,0,:] def overwrite_plus_n(arr,to_overwrite,n): arr[:,to_overwrite] = arr[:,int(to_overwrite+n)] return arr for to_overwrite in [1,2]: n = 4 dYY1,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res \ = [overwrite_plus_n(x,to_overwrite,n) for x in \ [dYY1,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res]] for to_overwrite in [7]: n = -4 dYY1,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res \ = [overwrite_plus_n(x,to_overwrite,n) for x in \ [dYY1,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res]] opto_dict = np.load(opto_activation_data_file,allow_pickle=True)[()] Yhat_opto = opto_dict['Yhat_opto'] Yhat_opto = np.ones((nN*2,nQ*nS*nT)) #Yhat_opto = Yhat_opto.reshape((nN*2,-1)) Yhat_opto[0::12] = np.nanmean(Yhat_opto[0::12],axis=0)[np.newaxis] Yhat_opto[1::12] = np.nanmean(Yhat_opto[1::12],axis=0)[np.newaxis] Yhat_opto = Yhat_opto/Yhat_opto[0::2].max(0)[np.newaxis,:] #print(Yhat_opto.shape) h_opto = np.zeros((nN*2,)) #h_opto = opto_dict['h_opto'] #dYY2 = Yhat_opto[1::2]-Yhat_opto[0::2] YYhat_chrimson = Yhat_opto.reshape((nN,2,-1)) opto_transform2 = calnet.utils.fit_opto_transform(YYhat_chrimson,norm01=norm_opto_transforms) dYY2 = opto_transform2.transform(YYhat) - opto_transform2.preprocess(YYhat) dYY = np.concatenate((dYY1,dYY2),axis=0) if ignore_halo_vip: dYY1[:,2::nQ] = np.nan from importlib import reload reload(calnet) reload(calnet.fitting_2step_spatial_feature_opto_multiout_axon_nonlinear) reload(sim_utils) wt_dict = {} wt_dict['X'] = 1 wt_dict['Y'] = 3 wt_dict['Eta'] = 3# 10 wt_dict['Xi'] = 3 wt_dict['stims'] = np.ones((nN,1)) #(np.arange(30)/30)[:,np.newaxis]**1 # wt_dict['barrier'] = 0. #30.0 #0.1 wt_dict['opto'] = 0#1e0#1e-1#1e1 wt_dict['smi'] = 0 wt_dict['isn'] = 0.1 wt_dict['tv'] = 1 YYhat = calnet.utils.flatten_nested_list_of_2d_arrays(Yhat) XXhat = calnet.utils.flatten_nested_list_of_2d_arrays(Xhat) Eta0 = invert_f_mt(YYhat) Xi0 = invert_fprime_mt(Ypc_list,Eta0,nN=nN,nQ=nQ,nS=nS,nT=nT,foldT=foldT) ntries = 1 nhyper = 1 dt = 1e-1 niter = int(np.round(10/dt)) #int(1e4) perturbation_size = 5e-2 W1t = [[None for itry in range(ntries)] for ihyper in range(nhyper)] W2t = [[None for itry in range(ntries)] for ihyper in range(nhyper)] loss = np.zeros((nhyper,ntries)) is_neg = np.array([b[1] for b in bounds1])==0 counter = 0 negatize = [np.zeros(shp,dtype='bool') for shp in shapes1] for ishp,shp in enumerate(shapes1): nel = np.prod(shp) negatize[ishp][:][is_neg[counter:counter+nel].reshape(shp)] = True counter = counter + nel for ihyper in range(nhyper): for itry in range(ntries): print((ihyper,itry)) W10list = [init_noise*(ihyper+1)*np.random.rand(*shp) for shp in shapes1] W20list = [init_noise*(ihyper+1)*np.random.rand(*shp) for shp in shapes2] counter = 0 for ishp,shp in enumerate(shapes1): W10list[ishp][negatize[ishp]] = -W10list[ishp][negatize[ishp]] nextraW = 4 nextraK = nextraW + 3 nextraT = nextraK + 3 #Wstar_dict['as_list'] = [W0x,W0y,W1x,W1y,W2x,W2y,W3x,W3y,s02,Kin0,Kin1,Kxout0,Kyout0,Kxout1,Kyout1,kappa,Tin0,Tin1,Txout0,Tyout0,Txout1,Tyout1,XX,XXp,Eta,Xi,h1,h2,bl,amp]#,h2 init_val = [1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1] W10list = [iv*np.ones(shp) for iv,shp in zip(init_val,shapes1)] #W10list[nextraW+4] = np.ones(shapes1[nextraW+4]) # s02 #W10list[nextraW+5] = np.ones(shapes1[nextraW+5]) # K #W10list[nextraW+6] = np.ones(shapes1[nextraW+6]) # K #W10list[nextraW+7] = np.zeros(shapes1[nextraW+7]) # K #W10list[nextraW+8] = np.zeros(shapes1[nextraW+8]) # K #W10list[nextraK+6] = np.ones(shapes1[nextraK+6]) # kappa #W10list[nextraK+7] = np.ones(shapes1[nextraK+7]) # T #W10list[nextraK+8] = np.ones(shapes1[nextraK+8]) # T #W10list[nextraK+9] = np.zeros(shapes1[nextraK+9]) # T #W10list[nextraK+10] = np.zeros(shapes1[nextraK+10]) # T W20list[0] = XXhat #np.concatenate(Xhat,axis=1) #XX W20list[1] = get_pc_dim(Xpc_list,nN=nN,nPQ=nP,nS=nS,nT=nT,idim=0,foldT=foldT) #XXp W20list[2] = Eta0 #np.zeros(shapes[nextraT+10]) #Eta W20list[3] = Xi0 #Xi #print(XXhat.shape) isn_init = np.array(((3,5),(-5,-5))) if init_W_from_lsq: # shapes1 #0.W0x,1.W0y,2.W1x,3.W1y,4.W2x,5.W2y,6.W3x,7.W3y,8.s02,9.Kin0,10.Kin1,11.Kout0,12.Kout1,13.kappa,14.Tin0,15.Tin1,16.Txout0,Tyout0,17.Txout1,Tyout1,18.h1,19.h2,20.bl,21.amp # shapes2 #0.XX,1.XXp,2.Eta,3.Xi #W0x,W0y,W1x,W1y,W2x,W2y,W3x,W3y,Kin0,Kin1,Tin0,Tin1 = initialize_Ws(Xhat,Yhat,Xpc_list,Ypc_list,scale_by=1) nvar,nxy = 4,2 freeze_vals = [[None for _ in range(nxy)] for _ in range(nvar)] lams = 1e5*np.array((0,1,1,1,0,1,0,1)) for ivar in range(nvar): for ixy in range(nxy): iflat = np.ravel_multi_index((ivar,ixy),(nvar,nxy)) freeze_vals[ivar][ixy] = np.zeros(bd1list[iflat].shape) freeze_vals[ivar][ixy][bd1list[iflat]==0] = np.nan if constrain_isn: freeze_vals[0][1][slice(0,None,3)][:,slice(0,None,3)] = isn_init #Wlist = [W0x,W0y,W1x,W1y,W2x,W2y,W3x,W3y,Kin0,Kin1,Kxout0,Kyout0,Kxout1,Kyout1,Tin0,Tin1,Txout0,Tyout0,Txout1,Tyout1] # W1list = [W0x,W0y,W1x,W1y,W2x,W2y,W3x,W3y,s02,Kin0,Kin1,Kxout0,Kyout0,Kxout1,Kyout1,kappa,Tin0,Tin1,Txout0,Tyout0,Txout1,Tyout1,h1,h2,bl,amp]#,h2 # W0,W1,W2,W3,Kin0,Kin1,Tin0,Tin1 thisWlist = initialize_Ws(Xhat,Yhat,Xpc_list,Ypc_list,scale_by=1,freeze_vals=freeze_vals,lams=lams,foldT=foldT) Winds = [0,1,2,3,4,5,6,7,9,10,11,12,13,14,16,17,18,19,20,21] for ivar,Wind in enumerate(Winds): W10list[Wind] = thisWlist[ivar] #W10list[0],W10list[1] = initialize_W(Xhat,Yhat,scale_by=scale_init_by) for Wind in Winds: W10list[Wind] = W10list[Wind] + init_noise*np.random.randn(*W10list[Wind].shape) else: if constrain_isn: W10list[1][slice(0,None,3)][:,slice(0,None,3)] = isn_init #W10list[1][0,0] = 3 #W10list[1][0,3] = 5 #W10list[1][3,0] = -5 #W10list[1][3,3] = -5 np.save('/home/dan/calnet_data/W0list.npy',{'W10list':W10list,'W20list':W20list,'bd1list':bd1list,'bd2list':bd2list,'freeze_vals':freeze_vals,'bounds1':bounds1,'bounds2':bounds2},allow_pickle=True) if init_W_from_file: # did not adjust this yet npyfile = np.load(init_file,allow_pickle=True)[()] print(len(npyfile['as_list'])) print([w.shape for w in npyfile['as_list']]) W10list = [npyfile['as_list'][ivar] for ivar in [0,1,2,3,4,5,6,7,12]] W20list = [npyfile['as_list'][ivar] for ivar in [8,9,10,11]] if correct_Eta: #assert(True==False) W20list[2] = Eta0.copy() if len(W10list) < len(shapes1): #assert(True==False) W10list = W10list + [np.array(1),np.zeros((nQ,)),np.zeros((nT*nS*nQ,))] # add bl, amp #np.array(1), #h2, #W10 = unparse_W(W10list) #W20 = unparse_W(W20list) opt = fmc.gen_opt() #resEta0,resXi0 = fmc.compute_res(W10,W20,opt) if init_W1xy_with_res: W1x0,W1y0,Kin10,Tin10 = optimize_W1xy(W10list,W20list,opt) W0list[2] = W1x0 W0list[3] = W1y0 W0list[10] = Kin10 W0list[15] = Tin10 if init_W2xy_with_res: W2x0,W2y0 = optimize_W2xy(W10list,W20list,opt) W0list[4] = W2x0 W0list[5] = W2y0 if init_Eta_with_s02: #assert(True==False) s02 = W10list[4].copy() Eta0 = invert_f_mt_with_s02(YYhat,s02,nS=nS,nT=nT) W20list[2] = Eta0.copy() for ivar in [0,1,4,5]: # Wmx, Wmy, s02, k print(init_noise) W10list[ivar] = W10list[ivar] + init_noise*np.random.randn(*W10list[ivar].shape) #W0list = npyfile['as_list'] extra_Ws = [np.zeros_like(W10list[ivar]) for ivar in range(2)] extra_ks = [np.zeros_like(W10list[5]) for ivar in range(3)] extra_Ts = [np.zeros_like(W10list[7]) for ivar in range(3)] W10list = W10list[:4] + extra_Ws*2 + W10list[4:6] + extra_ks + W10list[6:8] + extra_Ts + W10list[8:] print(len(W10list)) W1t[ihyper][itry],W2t[ihyper][itry],loss[ihyper][itry],gr,hess,result = calnet.fitting_2step_spatial_feature_opto_multiout_axon_nonlinear.fit_W_sim(Xhat,Xpc_list,Yhat,Ypc_list,pop_rate_fn=sim_utils.f_miller_troyer,pop_deriv_fn=sim_utils.fprime_miller_troyer,neuron_rate_fn=sim_utils.evaluate_f_mt,W10list=W10list.copy(),W20list=W20list.copy(),bounds1=bounds1,bounds2=bounds2,niter=niter,wt_dict=wt_dict,l2_penalty=l2_penalty,l1_penalty=l1_penalty,compute_hessian=False,dt=dt,perturbation_size=perturbation_size,dYY=dYY,constrain_isn=constrain_isn,tv=tv,foldT=foldT,use_opto_transforms=use_opto_transforms,opto_transform1=opto_transform1,opto_transform2=opto_transform2,nondim=nondim) #def parse_W(W): # W0x,W0y,W1x,W1y,W2x,W2y,W3x,W3y,s02,Kin0,Kin1,Kout0,Kout1,kappa,Tin0,Tin1,Txout0,Tyout0,Txout1,Tyout1,XX,XXp,Eta,Xi,h = W # return W0x,W0y,W1x,W1y,W2x,W2y,W3x,W3y,s02,Kin0,Kin1,Kout0,Kout1,kappa,Tin0,Tin1,Txout0,Tyout0,Txout1,Tyout1,XX,XXp,Eta,Xi,h def parse_W1(W): W0x,W0y,W1x,W1y,W2x,W2y,W3x,W3y,s02,Kin0,Kin1,Kxout0,Kyout0,Kxout1,Kyout1,kappa,Tin0,Tin1,Txout0,Tyout0,Txout1,Tyout1,h1,h2,bl,amp = W #h2, return W0x,W0y,W1x,W1y,W2x,W2y,W3x,W3y,s02,Kin0,Kin1,Kxout0,Kyout0,Kxout1,Kyout1,kappa,Tin0,Tin1,Txout0,Tyout0,Txout1,Tyout1,h1,h2,bl,amp #h2, def parse_W2(W): XX,XXp,Eta,Xi = W return XX,XXp,Eta,Xi def unparse_W(Ws): return np.concatenate([ww.flatten() for ww in Ws]) itry = 0 W0x,W0y,W1x,W1y,W2x,W2y,W3x,W3y,s02,Kin0,Kin1,Kxout0,Kyout0,Kxout1,Kyout1,kappa,Tin0,Tin1,Txout0,Tyout0,Txout1,Tyout1,h1,h2,bl,amp = parse_W1(W1t[0][0])#h2, XX,XXp,Eta,Xi = parse_W2(W2t[0][0]) #labels = ['W0x','W0y','W1x','W1y','W2x','W2y','W3x','W3y','s02','Kin0','Kin1','Kout0','Kout1','kappa','Tin0','Tin1','Tout0','Tout1','XX','XXp','Eta','Xi','h'] labels1 = ['W0x','W0y','W1x','W1y','W2x','W2y','W3x','W3y','s02','Kin0','Kin1','Kxout0','Kyout0','Kxout1','Kyout1','kappa','Tin0','Tin1','Txout0','Tyout0','Txout1','Tyout1','h1','h2','bl','amp']#,'h2' labels2 = ['XX','XXp','Eta','Xi'] Wstar_dict = {} for i,label in enumerate(labels1): Wstar_dict[label] = W1t[0][0][i] for i,label in enumerate(labels2): Wstar_dict[label] = W2t[0][0][i] #Wstar_dict = {} #for i,label in enumerate(labels): # Wstar_dict[label] = W1t[0][0][i] Wstar_dict['as_list'] = [W0x,W0y,W1x,W1y,W2x,W2y,W3x,W3y,s02,Kin0,Kin1,Kxout0,Kyout0,Kxout1,Kyout1,kappa,Tin0,Tin1,Txout0,Tyout0,Txout1,Tyout1,XX,XXp,Eta,Xi,h1,h2,bl,amp]#,h2 Wstar_dict['loss'] = loss[0][0] Wstar_dict['wt_dict'] = wt_dict np.save(weights_file,Wstar_dict,allow_pickle=True)
plt.imshow(normalize(kcsd_values[1:-1, :, 0]), vmin=-1, vmax=1, cmap='bwr', aspect='auto') plt.title('kCSD') plt.xlabel('Time') plt.subplot(144) plt.imshow(lfp[:, :, 50], vmin=-1, vmax=1, cmap='bwr', aspect='auto') plt.title('LFP') plt.xlabel('Time') plt.tight_layout() # %% Compute MSE -- mean squared error across space/time tcsd_meansqerr = np.nanmean(np.square( normalize(tcsd_pred[1:-1, :, :]) - normalize(csd_interior_electrodes[1:-1, :, 50:])), axis=(0, 1)) gpcsd_meansqerr = np.nanmean(np.square( normalize(gpcsd_model.csd_pred[1:-1, :, :]) - normalize(csd_interior_electrodes[1:-1, :, 50:])), axis=(0, 1)) kcsd_meansqerr = np.nanmean(np.square( normalize(kcsd_values[2:-2, :, :]) - normalize(csd_interior_electrodes[1:-1, :, 50:])), axis=(0, 1)) tcsd_rsq = 1 - np.sum(np.square( normalize(tcsd_pred[1:-1, :, :]) - normalize(csd_interior_electrodes[1:-1, :, 50:])), axis=(0, 1)) / np.sum(np.square( normalize(csd_interior_electrodes[1:-1, :, 50:])),
vmin=-1, vmax=1, cmap='bwr', aspect='auto') plt.title('Trad CSD prediction') plt.xlabel('Time (ms)') plt.subplot(144) plt.imshow(normalize(lfp3[:, :, 0]), vmin=-1, vmax=1, cmap='bwr', aspect='auto') plt.title('LFP') plt.xlabel('Time (ms)') plt.tight_layout() # %% gpcsd2_meansqerr = np.nanmean(np.square( normalize(gpcsd_model2.csd_pred[1:-1, :, :]) - normalize(csd2_interior_electrodes[1:-1, :, :])), axis=(0, 1)) gpcsd3_meansqerr = np.nanmean(np.square( normalize(gpcsd_model3.csd_pred[1:-1, :, :]) - normalize(csd3_interior_electrodes[1:-1, :, :])), axis=(0, 1)) print('GPCSD2 average MSE across trials: %0.3g' % np.mean(gpcsd2_meansqerr)) print('GPCSD3 average MSE across trials: %0.3g' % np.mean(gpcsd3_meansqerr)) # %%
jac=True, options={ 'maxiter': 5000, 'disp': True, 'ftol': 0 }, callback=callback0) PATH = ROOT_PATH + "/MMR_IVs/results/" + sname + "/" os.makedirs(PATH, exist_ok=True) np.save(PATH + 'LMO_errs_{}_nystr.npy'.format(seed), [opt_params, prev_norm, opt_test_err]) if __name__ == '__main__': snames = ['mnist_z', 'mnist_x', 'mnist_xz'] for sname in snames: for seed in range(100): experiment(sname, seed) PATH = ROOT_PATH + "/MMR_IVs/results/" + sname + "/" ress = [] for seed in range(100): filename = PATH + 'LMO_errs_{}_nystr.npy'.format(seed) if os.path.exists(filename): res = np.load(filename, allow_pickle=True) if res[-1] is not None: ress += [res[-1]] ress = np.array(ress) ress = remove_outliers(ress) print(np.nanmean(ress), np.nanstd(ress))
def adagrad_workflow_optimize(n_iters, objective_and_grad, init_param, K, has_log_norm=False, window=10, learning_rate=.01, learning_rate_end=None, epsilon=.1, tolerance=0.05, eval_elbo=100, stopping_rule=1, n_optimizers=1, r_mean_threshold=1.20, r_sigma_threshold=1.20, tail_avg_iters=200, plotting=False, model_name=None): """ stopping rule 1 means traditional ELBO stopping rule, while stopping rule 2 means MCSE stopping rule. The windowed Adagrad optimizer with convergence diagnostics and iterate averaging ... :param n_iters: :param objective_and_grad: :param init_param: initial params :param K: :param has_log_norm: :param window: :param learning_rate: :param epsilon: :param rhat_window: :param averaging: :param n_optimisers: :param r_mean_threshold: :param r_sigma_threshold: :param tail_avg_iters: :param eval_elbo: :param tolerance: :param stopping_rule: :param avg_grad_norm: :param learning_rate_end: :param plotting: :param model_name: :return: """ log_norm_history = [] variational_param = init_param.copy() prev_elbo = 0. pmz_size = init_param.size optimisation_log = {} variational_param_history_list = [] variational_param_post_conv_history_list = [] # index for iters t = 0 # index for iters after convergence .. j = 0 N_overall = 50000 sto_process_convergence = False sto_process_sigma_conv = False sto_process_mean_conv = False for o in range(n_optimizers): local_log_norm_history = [] local_grad_history = [] log_norm_history = [] value_history = [] elbo_diff_rel_med = 10. elbo_diff_rel_avg = 10. elbo_diff_rel_list = [] np.random.seed(seed=o) if o >= 1: variational_param = init_param + stats.norm.rvs( size=len(init_param)) * (o + 1) * 0.1 schedule = learning_rate_schedule(n_iters, learning_rate, learning_rate_end) t = 0 variational_param_history = [] variational_param_post_conv_history = [] mcse_all = np.zeros((pmz_size, 1)) stop = False for curr_learning_rate in schedule: if t == N_overall: break if sto_process_convergence: j = j + 1 if has_log_norm == 1: obj_val, obj_grad, log_norm = objective_and_grad( variational_param) else: obj_val, obj_grad = objective_and_grad(variational_param) log_norm = 0. if stopping_rule == 1 and t > 1000 and t % eval_elbo == 0: elbo_diff_rel = np.abs(obj_val - prev_elbo) / (prev_elbo + 1e-8) elbo_diff_rel_list.append(elbo_diff_rel) elbo_diff_rel_med = np.nanmedian(elbo_diff_rel_list) elbo_diff_rel_avg = np.nanmean(elbo_diff_rel_list) prev_elbo = obj_val start_stats = 1500 if stopping_rule == 2 and t > 1500 and t % eval_elbo == 0: #print(np.nanmedian(mcse_all[:, -1])) mcse_se_combined_list = monte_carlo_se( np.array(variational_param_history)[None, :], 0) mcse_all = np.hstack((mcse_all, mcse_se_combined_list[:, None])) value_history.append(obj_val) local_grad_history.append(obj_grad) local_log_norm_history.append(log_norm) log_norm_history.append(log_norm) if len(local_grad_history) > window: local_grad_history.pop(0) local_log_norm_history.pop(0) grad_scale = np.exp( np.min(local_log_norm_history) - np.array(local_log_norm_history)) scaled_grads = grad_scale[:, np.newaxis] * np.array( local_grad_history) accum_sum = np.sum(scaled_grads**2, axis=0) variational_param = variational_param - curr_learning_rate * obj_grad / np.sqrt( epsilon + accum_sum) #if i >= 0: variational_param_history.append(variational_param.copy()) if t % 10 == 0: avg_loss = np.mean(value_history[max(0, t - 1000):t + 1]) t = t + 1 if stopping_rule == 1 and stop == False and elbo_diff_rel_med <= tolerance: N_overall = t + 100 stop = True if stopping_rule == 1 and stop == False and elbo_diff_rel_avg <= tolerance: N_overall = t + 100 stop = True if stopping_rule ==2 and stop == False and sto_process_convergence == True and t > 1500 and \ t % eval_elbo == 0 and (np.nanmedian(mcse_all[:,-1]) <= epsilon) and j > 300: print('Optimization stopping reliably!') stop = True break variational_param_history_array = np.array( variational_param_history) if stopping_rule == 2 and t % eval_elbo == 0 and t > 800 and sto_process_convergence == False: variational_param_history_list.append( variational_param_history_array) variational_param_history_chains = np.stack( variational_param_history_list, axis=0) variational_param_history_list.pop(0) rhats_halfway_last = compute_R_hat( variational_param_history_chains, warmup=0.5)[1] rhat_mean_halfway, rhat_sigma_halfway = rhats_halfway_last[:K], rhats_halfway_last[ K:] if (rhat_mean_halfway < r_mean_threshold ).all() and sto_process_mean_conv == False: start_swa_m_iters = t print('Rhat- All means converged ...') sto_process_mean_conv = True start_stats = start_swa_m_iters if (rhat_sigma_halfway < r_sigma_threshold ).all() and sto_process_sigma_conv == False: start_swa_s_iters = t print('Rhat- All sigmas converged ...') sto_process_sigma_conv = True start_stats = start_swa_s_iters if sto_process_mean_conv == True and sto_process_sigma_conv == True: sto_process_convergence = True start_stats = np.maximum(start_swa_m_iters, start_swa_s_iters) if sto_process_convergence: variational_param_post_conv_history.append(variational_param) if sto_process_convergence and j > 100 and t % (eval_elbo) == 0: variational_param_post_conv_history_array = np.array( variational_param_post_conv_history) variational_param_post_conv_history_list.append( variational_param_post_conv_history_array) variational_param_post_conv_history_chains = np.stack( variational_param_post_conv_history_list, axis=0) variational_param_post_conv_history_list.pop(0) pmz_size = variational_param_post_conv_history_chains.shape[2] Neff = np.zeros(pmz_size) Rhot = [] khat_iterates = [] khat_iterates2 = [] # compute khat for iterates for k in range(pmz_size): neff, rho_t_sum, autocov, rho_t = autocorrelation( variational_param_post_conv_history_chains, 0, k) #mcse_se_combined = monte_carlo_se2(variational_param_history_chains, start_stats,i) Neff[k] = neff #mcmc_se2.append(mcse_se_combined) Rhot.append(rho_t) khat_i = compute_khat_iterates( variational_param_post_conv_history_chains, 0, k, increasing=True) khat_iterates.append(khat_i) khat_i2 = compute_khat_iterates( variational_param_post_conv_history_chains, 0, k, increasing=False) khat_iterates2.append(khat_i2) rhot_array = np.stack(Rhot, axis=0) khat_combined = np.maximum(khat_iterates, khat_iterates2) if sto_process_convergence: optimisation_log['start_avg_mean_iters'] = start_swa_m_iters optimisation_log['start_avg_sigma_iters'] = start_swa_s_iters optimisation_log['r_hat_mean_halfway'] = rhat_mean_halfway optimisation_log['r_hat_sigma_halfway'] = rhat_sigma_halfway try: Neff except NameError: pass else: optimisation_log['neff'] = Neff optimisation_log['autocov'] = autocov optimisation_log['rhot'] = rhot_array optimisation_log['start_stats'] = start_stats # optimisation_log['mcmc_se2'] = mcmc_se2_array optimisation_log['khat_iterates_comb'] = khat_combined if stopping_rule == 1: start_stats = t - tail_avg_iters if stopping_rule == 1: smoothed_opt_param = np.mean( variational_param_history_array[start_stats:, :], axis=0) elif stopping_rule == 2 and sto_process_convergence == True: smoothed_opt_param = np.mean( variational_param_post_conv_history_chains[0, :], axis=0) if stopping_rule == 2 and sto_process_convergence == False: smoothed_opt_param = np.mean( variational_param_history_array[start_stats:, :], axis=0) if plotting: fig = plt.figure(figsize=(4.2, 2.5)) ax = fig.add_subplot(1, 1, 1) ax.plot(rhot_array[0, :100], label='loc-1') ax.plot(rhot_array[1, :100], label='loc-2') #ax.plot(rhot_array[2, :100], label='loc-3') plt.xlabel('Lags') plt.ylabel('autocorrelation') plt.legend() plt.savefig('autocor_model_adagrad_mean_mf.pdf') fig = plt.figure(figsize=(4.2, 2.5)) ax = fig.add_subplot(1, 1, 1) ax.plot(rhot_array[K, :100], label='sigma-1') ax.plot(rhot_array[K + 1, :100], label='sigma-2') #ax.plot(rhot_array[K + 2, :100], label='sigma-3') plt.xlabel('Lags') plt.ylabel('autocorrelation') plt.legend() plt.savefig('autocor_model_adagrad_sigma_mf.pdf') khat_array = optimisation_log['khat_iterates_comb'] return (smoothed_opt_param, variational_param_history, np.array(value_history), np.array(log_norm_history), optimisation_log)
def adam_workflow_optimize(n_iters, objective_and_grad, init_param, K, has_log_norm=False, window=100, learning_rate=.01, learning_rate_end=None, epsilon=.02, averaging=True, n_optimisers=1, r_mean_threshold=1.20, r_sigma_threshold=1.20, tail_avg_iters=200, eval_elbo=100, tolerance=0.01, stopping_rule=1, plotting=True, model_name=None): """ stopping rule 1 means traditional ELBO stopping rule, while stopping rule 2 means MCSE stopping rule. The windowed ADAM optimizer with the convergence diagnostics and iterate averaging ... :param n_iters: :param objective_and_grad: :param init_param: initial params :param K: :param has_log_norm: :param window: :param learning_rate: :param epsilon: :param rhat_window: :param averaging: :param n_optimisers: :param r_mean_threshold: :param r_sigma_threshold: :param tail_avg_iters: :param eval_elbo: :param tolerance: :param stopping_rule: :param avg_grad_norm: :param learning_rate_end: :param plotting: :param model_name: :return: """ optimisation_log = {} variational_param_post_conv_history_list = [] # index for iters t = 0 # index for iters after convergence .. j = 0 N_overall = 50000 sto_process_convergence = False sto_process_sigma_conv = False sto_process_mean_conv = False value_history = [] log_norm_history = [] variational_param = init_param.copy() averaged_variational_param_history = [] start_avg_iter = n_iters // 1.3 variational_param_history_list = [] averaged_variational_mean_list = [] averaged_variational_sigmas_list = [] grad_val = 0. grad_squared = 0 beta1 = 0.9 beta2 = 0.999 prev_elbo = 0. pmz_size = init_param.size mcse_all = np.zeros(pmz_size) for o in range(n_optimisers): np.random.seed(seed=o) if o >= 1: variational_param = init_param + stats.norm.rvs( size=len(init_param)) * (o + 1) * 0.5 elbo_diff_rel_med = 10. elbo_diff_rel_avg = 10. local_grad_history = [] local_log_norm_history = [] value_history = [] log_norm_history = [] averaged_variational_mean_list = [] averaged_variational_sigmas_list = [] elbo_diff_rel_list = [] variational_param = init_param.copy() t = 0 variational_param_history = [] variational_param_post_conv_history = [] mcse_all = np.zeros((pmz_size, 1)) stop = False with tqdm.trange(n_iters) as progress: try: schedule = learning_rate_schedule(n_iters, learning_rate, learning_rate_end) for i, curr_learning_rate in zip(progress, schedule): if i == N_overall: break if sto_process_convergence: j = j + 1 if has_log_norm == 1: obj_val, obj_grad, log_norm = objective_and_grad( variational_param) else: obj_val, obj_grad = objective_and_grad( variational_param) log_norm = 0 if stopping_rule == 1 and i > 1000 and i % eval_elbo == 0: elbo_diff_rel = np.abs(obj_val - prev_elbo) / (prev_elbo + 1e-8) elbo_diff_rel_list.append(elbo_diff_rel) elbo_diff_rel_med = np.nanmedian(elbo_diff_rel_list) elbo_diff_rel_avg = np.nanmean(elbo_diff_rel_list) prev_elbo = obj_val start_stats = 1000 mcse_se_combined_list = np.zeros((pmz_size, 1)) if stopping_rule == 2 and i > 1000 and i % eval_elbo == 0: mcse_se_combined_list = monte_carlo_se( np.array(variational_param_history)[None, :], 0) mcse_all = np.hstack( (mcse_all, mcse_se_combined_list[:, None])) value_history.append(obj_val) local_grad_history.append(obj_grad) local_log_norm_history.append(log_norm) log_norm_history.append(log_norm) if len(local_grad_history) > window: local_grad_history.pop(0) local_log_norm_history.pop(0) if has_log_norm: grad_norm = np.exp(log_norm) else: grad_norm = np.sum(obj_grad**2, axis=0) if i == 0: grad_squared = 0.9 * obj_grad**2 grad_val = 0.9 * obj_grad else: grad_squared = grad_squared * beta2 + ( 1. - beta2) * obj_grad**2 grad_val = grad_val * beta1 + (1. - beta1) * obj_grad grad_scale = np.exp( np.min(local_log_norm_history) - np.array(local_log_norm_history)) scaled_grads = grad_scale[:, np.newaxis] * np.array( local_grad_history) accum_sum = np.sum(scaled_grads**2, axis=0) old_variational_param = variational_param.copy() m_hat = grad_val / (1 - np.power(beta1, i + 2)) v_hat = grad_squared / (1 - np.power(beta2, i + 2)) variational_param = variational_param - curr_learning_rate * m_hat / np.sqrt( epsilon + v_hat) if averaging is True and i > start_avg_iter: averaged_variational_param = ( variational_param + old_variational_param * (i - start_avg_iter)) / (i - start_avg_iter + 1) averaged_variational_param_history.append( averaged_variational_param) if i > 100: variational_param_history.append(old_variational_param) if len(variational_param_history) > 100 * window: variational_param_history.pop(0) if i % 100 == 0: avg_loss = np.mean(value_history[max(0, i - 1000):i + 1]) #print(avg_loss) progress.set_description( 'Average Loss = {:,.6g}'.format(avg_loss)) t = t + 1 if stopping_rule == 1 and stop == False and elbo_diff_rel_med <= epsilon: print('Convergence achieved due to ELBO median') N_overall = i + 100 stop = True if stopping_rule == 1 and stop == False and elbo_diff_rel_avg <= epsilon: print('Convergence achieved due to ELBO mean') N_overall = i + 100 stop = True if stopping_rule == 2 and stop == False and sto_process_convergence == True and i > 1500 and \ t % eval_elbo == 0 and (np.nanmedian(mcse_all[:, -1]) <= epsilon) and j > 500: print('Optimization stopping reliably!') stop = True break variational_param_history_array = np.array( variational_param_history) if stopping_rule == 2 and t % eval_elbo == 0 and t > 1000 and sto_process_convergence == False: variational_param_history_list.append( variational_param_history_array) variational_param_history_chains = np.stack( variational_param_history_list, axis=0) variational_param_history_list.pop(0) rhats_halfway_last = compute_R_hat( variational_param_history_chains, warmup=0.5)[1] rhat_mean_halfway, rhat_sigma_halfway = rhats_halfway_last[:K], rhats_halfway_last[ K:] if (rhat_mean_halfway < r_mean_threshold ).all() and sto_process_mean_conv == False: start_swa_m_iters = i print('Rhat- All mean converged ...') sto_process_mean_conv = True start_stats = start_swa_m_iters if (rhat_sigma_halfway < r_sigma_threshold ).all() and sto_process_sigma_conv == False: start_swa_s_iters = i print('Rhat- All sigmas converged ...') sto_process_sigma_conv = True start_stats = start_swa_s_iters if sto_process_mean_conv == True and sto_process_sigma_conv == True: sto_process_convergence = True start_stats = np.maximum(start_swa_m_iters, start_swa_s_iters) if sto_process_convergence: variational_param_post_conv_history.append( variational_param) if sto_process_convergence and j > 200 and t % eval_elbo == 0: variational_param_post_conv_history_array = np.array( variational_param_post_conv_history) variational_param_post_conv_history_list.append( variational_param_post_conv_history_array) variational_param_post_conv_history_chains = np.stack( variational_param_post_conv_history_list, axis=0) variational_param_post_conv_history_list.pop(0) pmz_size = variational_param_post_conv_history_chains.shape[ 2] Neff = np.zeros(pmz_size) Rhot = [] khat_iterates = [] khat_iterates2 = [] # compute khat for iterates for z in range(pmz_size): neff, rho_t_sum, autocov, rho_t = autocorrelation( variational_param_post_conv_history_chains, 0, z) Neff[z] = neff Rhot.append(rho_t) khat_i = compute_khat_iterates( variational_param_post_conv_history_chains, 0, z, increasing=True) khat_iterates.append(khat_i) khat_i2 = compute_khat_iterates( variational_param_post_conv_history_chains, 0, z, increasing=False) khat_iterates2.append(khat_i2) rhot_array = np.stack(Rhot, axis=0) khat_combined = np.maximum(khat_iterates, khat_iterates2) except (KeyboardInterrupt, StopIteration) as e: progress.close() finally: progress.close() if sto_process_convergence: optimisation_log['start_avg_mean_iters'] = start_swa_m_iters optimisation_log['start_avg_sigma_iters'] = start_swa_s_iters optimisation_log['r_hat_mean_halfway'] = rhat_mean_halfway optimisation_log['r_hat_sigma_halfway'] = rhat_sigma_halfway try: Neff except NameError: pass else: optimisation_log['neff'] = Neff optimisation_log['autocov'] = autocov optimisation_log['rhot'] = rhot_array optimisation_log['start_stats'] = start_stats # optimisation_log['mcmc_se2'] = mcmc_se2_array optimisation_log['khat_iterates_comb'] = khat_combined if stopping_rule == 1: start_stats = i - tail_avg_iters if stopping_rule == 1: variational_param_history_list.append(variational_param_history_array) variational_param_history_chains = np.stack( variational_param_history_list, axis=0) smoothed_opt_param = np.mean( variational_param_history_array[start_stats:, :], axis=0) averaged_variational_mean_list.append(smoothed_opt_param[:K]) averaged_variational_sigmas_list.append(smoothed_opt_param[K:]) elif stopping_rule == 2 and sto_process_convergence == True: smoothed_opt_param = np.mean( variational_param_post_conv_history_chains[0, :, :], axis=0) averaged_variational_mean_list.append(smoothed_opt_param[:K]) averaged_variational_sigmas_list.append(smoothed_opt_param[K:]) if stopping_rule == 2 and sto_process_convergence == False: start_stats = t - tail_avg_iters variational_param_history_list.append(variational_param_history_array) variational_param_history_chains = np.stack( variational_param_history_list, axis=0) smoothed_opt_param = np.mean( variational_param_history_array[start_stats:, :], axis=0) averaged_variational_mean_list.append(smoothed_opt_param[:K]) averaged_variational_sigmas_list.append(smoothed_opt_param[K:]) if plotting: fig = plt.figure(figsize=(4.2, 2.5)) ax = fig.add_subplot(1, 1, 1) ax.plot(rhot_array[0, :100], label='loc-1') ax.plot(rhot_array[1, :100], label='loc-2') #ax.plot(rhot_array[2, :100], label='loc-3') plt.xlabel('Lags') plt.ylabel('autocorrelation') plt.legend() plt.savefig('autocor_model_adam_mean_mf.pdf') fig = plt.figure(figsize=(4.2, 2.5)) ax = fig.add_subplot(1, 1, 1) ax.plot(rhot_array[K, :100], label='sigma-1') ax.plot(rhot_array[K + 1, :100], label='sigma-2') #ax.plot(rhot_array[K + 2, :100], label='sigma-3') plt.xlabel('Lags') plt.ylabel('autocorrelation') plt.legend() plt.savefig('autocor_model_adam_sigma_mf.pdf') return (variational_param, variational_param_history_chains, averaged_variational_mean_list, averaged_variational_sigmas_list, np.array(value_history), np.array(log_norm_history), optimisation_log)
def columnize(arr): output = np.nanmean(arr, 0).flatten() output = output / output.max() return output
def combiner(sem, axis=1): return np.sqrt(np.nanmean(sem**2, axis=axis))
def fit_weights_and_save(weights_file,ca_data_file='rs_vm_denoise_200605.npy',opto_data_file='vip_halo_data_for_sim.npy',constrain_wts=None,allow_var=True,fit_s02=True,constrain_isn=True,tv=False,l2_penalty=0.01,init_noise=0.1,init_W_from_lsq=False,scale_init_by=1,init_W_from_file=False,init_file=None): nsize,ncontrast = 6,6 #print('ca data file: '+ca_data_file) npfile = np.load(ca_data_file,allow_pickle=True)[()]#,{'rs':rs},allow_pickle=True) # ,'rs_denoise':rs_denoise rs = npfile['rs'] #rs_denoise = npfile['rs_denoise'] nsize,ncontrast,ndir = 6,6,8 ori_dirs = [[0,4],[2,6]] #[[0,4],[1,3,5,7],[2,6]] nT = len(ori_dirs) #nS = len(rs_denoise[0]) nS = len(rs[0]) #print('rs mean: '+str(np.nanmean(rs[0][0]))) #print('rs isnan: '+str(np.nanmean(np.isnan(rs[0][0])))) def sum_to_1(r): R = r.reshape((r.shape[0],-1)) #R = R/np.nansum(R[:,~np.isnan(R.sum(0))],axis=1)[:,np.newaxis] R = R/np.nansum(R,axis=1)[:,np.newaxis] # changed 8/28 return R def norm_to_mean(r): R = r.reshape((r.shape[0],-1)) R = R/np.nanmean(R[:,~np.isnan(R.sum(0))],axis=1)[:,np.newaxis] return R Rs = [[None,None] for i in range(len(rs))] Rso = [[[None for iT in range(nT)] for iS in range(nS)] for icelltype in range(len(rs))] rso = [[[None for iT in range(nT)] for iS in range(nS)] for icelltype in range(len(rs))] for iR,r in enumerate(rs):#rs_denoise): print(iR) for ialign in range(nS): Rs[iR][ialign] = sum_to_1(r[ialign][:,:nsize,:]) # Rs[iR][ialign] = von_mises_denoise(Rs[iR][ialign].reshape((-1,nsize,ncontrast,ndir))) #print('Rs isnan: '+str(np.nanmean(np.isnan(Rs[0][0])))) kernel = np.ones((1,2,2)) kernel = kernel/kernel.sum() for iR,r in enumerate(rs): for ialign in range(nS): for iori in range(nT): Rso[iR][ialign][iori] = np.nanmean(Rs[iR][ialign].reshape((-1,nsize,ncontrast,ndir))[:,:,:,ori_dirs[iori]],-1) Rso[iR][ialign][iori][:,:,0] = np.nanmean(Rso[iR][ialign][iori][:,:,0],1)[:,np.newaxis] #print('Rso isnan before conv: '+str(np.nanmean(np.isnan(Rso[iR][ialign][iori])))) Rso[iR][ialign][iori][:,1:,1:] = ssi.convolve(Rso[iR][ialign][iori],kernel,'valid') #print('Rso isnan after conv: '+str(np.nanmean(np.isnan(Rso[iR][ialign][iori])))) Rso[iR][ialign][iori] = Rso[iR][ialign][iori].reshape(Rso[iR][ialign][iori].shape[0],-1) #print('Rso isnan: '+str(np.nanmean(np.isnan(Rso[0][0][0])))) #kernel = np.ones((1,2,2)) #kernel = kernel/kernel.sum() # #for iR,r in enumerate(rs): # for ialign in range(nS): # for iori in range(nT): # Rso[iR][ialign][iori] = np.nanmean(Rs[iR][ialign].reshape((-1,nsize,ncontrast,ndir))[:,:,:,ori_dirs[iori]],-1) # Rso[iR][ialign][iori] = ssi.convolve(Rso[iR][ialign][iori],kernel,'same') # Rso[iR][ialign][iori] = Rso[iR][ialign][iori].reshape(Rso[iR][ialign][iori].shape[0],-1) def set_bound(bd,code,val=0): # set bounds to 0 where 0s occur in 'code' for iitem in range(len(bd)): bd[iitem][code[iitem]] = val nN = 36 nS = 2 nP = 2 nT = 2 nQ = 4 # code for bounds: 0 , constrained to 0 # +/-1 , constrained to +/-1 # 1.5, constrained to [0,1] # 2 , constrained to [0,inf) # -2 , constrained to (-inf,0] # 3 , unconstrained Wmx_bounds = 3*np.ones((nP,nQ),dtype=int) Wmx_bounds[0,1] = 0 # SSTs don't receive L4 input if allow_var: Wsx_bounds = 3*np.ones(Wmx_bounds.shape) #Wmx_bounds.copy()*0 #np.zeros_like(Wmx_bounds) Wsx_bounds[0,1] = 0 else: Wsx_bounds = np.zeros(Wmx_bounds.shape) #Wmx_bounds.copy()*0 #np.zeros_like(Wmx_bounds) Wmy_bounds = 3*np.ones((nQ,nQ),dtype=int) Wmy_bounds[0,:] = 2 # PCs are excitatory Wmy_bounds[1:,:] = -2 # all the cell types except PCs are inhibitory Wmy_bounds[1,1] = 0 # SSTs don't inhibit themselves # Wmy_bounds[3,1] = 0 # PVs are allowed to inhibit SSTs, consistent with Hillel's unpublished results, but not consistent with Pfeffer et al. Wmy_bounds[2,0] = 0 # VIPs don't inhibit L2/3 PCs. According to Pfeffer et al., only L5 PCs were found to get VIP inhibition if allow_var: Wsy_bounds = 3*np.ones(Wmy_bounds.shape) #Wmy_bounds.copy()*0 #np.zeros_like(Wmy_bounds) Wsy_bounds[1,1] = 0 Wsy_bounds[3,1] = 0 Wsy_bounds[2,0] = 0 else: Wsy_bounds = np.zeros(Wmy_bounds.shape) #Wmy_bounds.copy()*0 #np.zeros_like(Wmy_bounds) if not constrain_wts is None: for wt in constrain_wts: Wmy_bounds[wt[0],wt[1]] = 0 Wsy_bounds[wt[0],wt[1]] = 0 def tile_nS_nT_nN(kernel): row = np.concatenate([kernel for idim in range(nS*nT)],axis=0)[np.newaxis,:] tiled = np.concatenate([row for irow in range(nN)],axis=0) return tiled if fit_s02: s02_bounds = 2*np.ones((nQ,)) # permitting noise as a free parameter else: s02_bounds = np.ones((nQ,)) k_bounds = 1.5*np.ones((nQ,)) kappa_bounds = np.ones((1,)) # kappa_bounds = 2*np.ones((1,)) T_bounds = 1.5*np.ones((nQ,)) #T_bounds[2:4] = 1 # PV and VIP are constrained to have flat ori tuning T_bounds[1:4] = 1 # SST,VIP, and PV are constrained to have flat ori tuning X_bounds = tile_nS_nT_nN(np.array([2,1])) # X_bounds = np.array([np.array([2,1,2,1])]*nN) Xp_bounds = tile_nS_nT_nN(np.array([3,1])) # Xp_bounds = np.array([np.array([3,1,3,1])]*nN) # Y_bounds = tile_nS_nT_nN(2*np.ones((nQ,))) # # Y_bounds = 2*np.ones((nN,nT*nS*nQ)) Eta_bounds = tile_nS_nT_nN(3*np.ones((nQ,))) # Eta_bounds = 3*np.ones((nN,nT*nS*nQ)) if allow_var: Xi_bounds = tile_nS_nT_nN(3*np.ones((nQ,))) else: Xi_bounds = tile_nS_nT_nN(np.zeros((nQ,))) # Xi_bounds = 3*np.ones((nN,nT*nS*nQ)) h_bounds = -2*np.ones((1,)) # shapes = [(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nQ,),(nQ,),(1,),(nN,nS*nP),(nN,nS*nQ),(nN,nS*nQ),(nN,nS*nQ)] shapes = [(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nQ,),(nQ,),(1,),(nQ,),(nN,nT*nS*nP),(nN,nT*nS*nP),(nN,nT*nS*nQ),(nN,nT*nS*nQ),(1,)] # Wmx, Wmy, Wsx, Wsy, s02, k, kappa,T, XX, XXp, Eta, Xi lb = [-np.inf*np.ones(shp) for shp in shapes] ub = [np.inf*np.ones(shp) for shp in shapes] bdlist = [Wmx_bounds,Wmy_bounds,Wsx_bounds,Wsy_bounds,s02_bounds,k_bounds,kappa_bounds,T_bounds,X_bounds,Xp_bounds,Eta_bounds,Xi_bounds,h_bounds] set_bound(lb,[bd==0 for bd in bdlist],val=0) set_bound(ub,[bd==0 for bd in bdlist],val=0) set_bound(lb,[bd==2 for bd in bdlist],val=0) set_bound(ub,[bd==-2 for bd in bdlist],val=0) set_bound(lb,[bd==1 for bd in bdlist],val=1) set_bound(ub,[bd==1 for bd in bdlist],val=1) set_bound(lb,[bd==1.5 for bd in bdlist],val=0) set_bound(ub,[bd==1.5 for bd in bdlist],val=1) set_bound(lb,[bd==-1 for bd in bdlist],val=-1) set_bound(ub,[bd==-1 for bd in bdlist],val=-1) # for bd in [lb,ub]: # for ind in [2,3]: # bd[ind][:,1] = 0 # temporary for no variation expt. # lb[2] = np.zeros_like(lb[2]) # lb[3] = np.zeros_like(lb[3]) # lb[4] = np.ones_like(lb[4]) # lb[5] = np.zeros_like(lb[5]) # ub[2] = np.zeros_like(ub[2]) # ub[3] = np.zeros_like(ub[3]) # ub[4] = np.ones_like(ub[4]) # ub[5] = np.ones_like(ub[5]) # temporary for no variation expt. lb = np.concatenate([a.flatten() for a in lb]) ub = np.concatenate([b.flatten() for b in ub]) bounds = [(a,b) for a,b in zip(lb,ub)] nS = 2 ndims = 5 ncelltypes = 5 Yhat = [[None for iT in range(nT)] for iS in range(nS)] Xhat = [[None for iT in range(nT)] for iS in range(nS)] Ypc_list = [[None for iT in range(nT)] for iS in range(nS)] Xpc_list = [[None for iT in range(nT)] for iS in range(nS)] for iS in range(nS): mx = np.zeros((ncelltypes,)) yy = [None for icelltype in range(ncelltypes)] for icelltype in range(ncelltypes): yy[icelltype] = np.nanmean(Rso[icelltype][iS][0],0) mx[icelltype] = np.nanmax(yy[icelltype]) for iT in range(nT): y = [np.nanmean(Rso[icelltype][iS][iT],axis=0)[:,np.newaxis]/mx[icelltype] for icelltype in range(1,ncelltypes)] Ypc_list[iS][iT] = [None for icelltype in range(1,ncelltypes)] for icelltype in range(1,ncelltypes): rss = Rso[icelltype][iS][iT].copy() #.reshape(Rs[icelltype][ialign].shape[0],-1) rss = rss[np.isnan(rss).sum(1)==0] # print(rss.max()) # rss[rss<0] = 0 # rss = rss[np.random.randn(rss.shape[0])>0] try: u,s,v = np.linalg.svd(rss-np.mean(rss,0)[np.newaxis]) Ypc_list[iS][iT][icelltype-1] = [(s[idim],v[idim]) for idim in range(ndims)] # print('yep on Y') # print(np.min(np.sum(rs[icelltype][iS][iT],axis=1))) except: print('nope on Y') #print(np.mean(np.isnan(rss))) #print(np.min(np.sum(rs[icelltype][iS][iT],axis=1))) Yhat[iS][iT] = np.concatenate(y,axis=1) # x = sim_utils.columnize(Rso[0][iS][iT])[:,np.newaxis] icelltype = 0 x = np.nanmean(Rso[icelltype][iS][iT],0)[:,np.newaxis]/mx[icelltype] # opto_column = np.concatenate((np.zeros((nN,)),np.zeros((nNO/2,)),np.ones((nNO/2,))),axis=0)[:,np.newaxis] Xhat[iS][iT] = np.concatenate((x,np.ones_like(x)),axis=1) # Xhat[iS][iT] = np.concatenate((x,np.ones_like(x),opto_column),axis=1) icelltype = 0 rss = Rso[icelltype][iS][iT].copy() rss = rss[np.isnan(rss).sum(1)==0] # try: u,s,v = np.linalg.svd(rss-rss.mean(0)[np.newaxis]) #print(np.min(np.isnan(Rso[icelltype][iS][iT]).sum(1))) #print('Rso shape: '+str(Rso[icelltype][iS][iT].shape)) #print('rss shape: '+str(rss.shape)) #print('s shape: '+str(s.shape)) #print('v shape: '+str(v.shape)) Xpc_list[iS][iT] = [None for iinput in range(2)] Xpc_list[iS][iT][0] = [(s[idim],v[idim]) for idim in range(ndims)] Xpc_list[iS][iT][1] = [(0,np.zeros((Xhat[0][0].shape[0],))) for idim in range(ndims)] # except: # print('nope on X') # print(np.mean(np.isnan(rss))) # print(np.min(np.sum(Rso[icelltype][iS][iT],axis=1))) nN,nP = Xhat[0][0].shape nQ = Yhat[0][0].shape[1] def compute_f_(Eta,Xi,s02): return sim_utils.f_miller_troyer(Eta,Xi**2+np.concatenate([s02 for ipixel in range(nS*nT)])) def compute_fprime_m_(Eta,Xi,s02): return sim_utils.fprime_miller_troyer(Eta,Xi**2+np.concatenate([s02 for ipixel in range(nS*nT)]))*Xi def compute_fprime_s_(Eta,Xi,s02): s2 = Xi**2+np.concatenate((s02,s02),axis=0) return sim_utils.fprime_s_miller_troyer(Eta,s2)*(Xi/s2) def sorted_r_eigs(w): drW,prW = np.linalg.eig(w) srtinds = np.argsort(drW) return drW[srtinds],prW[:,srtinds] # 0.Wmx, 1.Wmy, 2.Wsx, 3.Wsy, 4.s02,5.K, 6.kappa,7.T,8.XX, 9.XXp, 10.Eta, 11.Xi shapes = [(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nQ,),(nQ,),(1,),(nQ,),(nN,nT*nS*nP),(nN,nT*nS*nP),(nN,nT*nS*nQ),(nN,nT*nS*nQ),(1,)] import calnet.fitting_spatial_feature import sim_utils opto_dict = np.load(opto_data_file,allow_pickle=True)[()] Yhat_opto = opto_dict['Yhat_opto'] Yhat_opto = Yhat_opto/Yhat_opto[0::2].max(0)[np.newaxis,:] print(Yhat_opto.shape) h_opto = opto_dict['h_opto'] dYY = Yhat_opto[1::2]-Yhat_opto[0::2] for to_overwrite in [1,2,5,6]: dYY[:,to_overwrite] = dYY[:,to_overwrite+8] for to_overwrite in [11,15]: dYY[:,to_overwrite] = dYY[:,to_overwrite-8] from importlib import reload reload(calnet) reload(calnet.fitting_spatial_feature_opto) reload(sim_utils) # reload(calnet.fitting_spatial_feature) # W0list = [np.ones(shp) for shp in shapes] wt_dict = {} wt_dict['X'] = 1 wt_dict['Y'] = 3 wt_dict['Eta'] = 1# 10 wt_dict['Xi'] = 0.1 wt_dict['stims'] = np.ones((nN,1)) #(np.arange(30)/30)[:,np.newaxis]**1 # wt_dict['barrier'] = 0. #30.0 #0.1 wt_dict['opto'] = 1e0#1e-1#1e1 wt_dict['isn'] = 0.1 wt_dict['tv'] = 0. YYhat = calnet.utils.flatten_nested_list_of_2d_arrays(Yhat) XXhat = calnet.utils.flatten_nested_list_of_2d_arrays(Xhat) Eta0 = invert_f_mt(YYhat) ntries = 1 nhyper = 1 dt = 1e-1 niter = int(np.round(10/dt)) #int(1e4) perturbation_size = 5e-2 # learning_rate = 1e-4 # 1e-5 #np.linspace(3e-4,1e-3,niter+1) # 1e-5 #l2_penalty = 0.1 Wt = [[None for itry in range(ntries)] for ihyper in range(nhyper)] loss = np.zeros((nhyper,ntries)) is_neg = np.array([b[1] for b in bounds])==0 counter = 0 negatize = [np.zeros(shp,dtype='bool') for shp in shapes] for ishp,shp in enumerate(shapes): nel = np.prod(shp) negatize[ishp][:][is_neg[counter:counter+nel].reshape(shp)] = True counter = counter + nel for ihyper in range(nhyper): for itry in range(ntries): print((ihyper,itry)) W0list = [init_noise*(ihyper+1)*np.random.rand(*shp) for shp in shapes] counter = 0 for ishp,shp in enumerate(shapes): W0list[ishp][negatize[ishp]] = -W0list[ishp][negatize[ishp]] W0list[4] = np.ones(shapes[5]) # s02 W0list[5] = np.ones(shapes[5]) # K W0list[6] = np.ones(shapes[6]) # kappa W0list[7] = np.ones(shapes[7]) # T W0list[8] = np.concatenate(Xhat,axis=1) #XX W0list[9] = np.zeros_like(W0list[8]) #XXp W0list[10] = Eta0 #np.zeros(shapes[10]) #Eta W0list[11] = np.zeros(shapes[11]) #Xi #[Wmx,Wmy,Wsx,Wsy,s02,k,kappa,T,XX,XXp,Eta,Xi] # W0list = Wstar_dict['as_list'].copy() # W0list[1][1,0] = -1.5 # W0list[1][3,0] = -1.5 if init_W_from_lsq: W0list[0],W0list[1] = initialize_W(Xhat,Yhat,scale_by=scale_init_by) for ivar in range(0,2): W0list[ivar] = W0list[ivar] + init_noise*np.random.randn(*W0list[ivar].shape) if constrain_isn: W0list[1][0,0] = 3 W0list[1][0,3] = 5 W0list[1][3,0] = -5 W0list[1][3,3] = -5 if init_W_from_file: npyfile = np.load(init_file,allow_pickle=True)[()] W0list = npyfile['as_list'] #W0list[7][0] = 0 # T # alternative initialization #n = 0.5 #W0list[7][0] = 1/(n+1)*(W0list[7][0] + n*0) # T #W0list[7][3] = 1/(n+1)*(W0list[7][3] + n*1) # T #W0list[1][1,0] = W0list[1][1,0] #[Wmx,Wmy,Wsx,Wsy,s02,k,kappa,T,XX,XXp,Eta,Xi] for ivar in [0,1,4,5]: # Wmx, Wmy, s02, k W0list[ivar] = W0list[ivar] + init_noise*np.random.randn(*W0list[ivar].shape) # wt_dict['Xi'] = 10 # wt_dict['Eta'] = 10 Wt[ihyper][itry],loss[ihyper][itry],gr,hess,result = calnet.fitting_spatial_feature_opto.fit_W_sim(Xhat,Xpc_list,Yhat,Ypc_list,pop_rate_fn=sim_utils.f_miller_troyer,pop_deriv_fn=sim_utils.fprime_miller_troyer,neuron_rate_fn=sim_utils.evaluate_f_mt,W0list=W0list.copy(),bounds=bounds,niter=niter,wt_dict=wt_dict,l2_penalty=l2_penalty,compute_hessian=False,dt=dt,perturbation_size=perturbation_size,dYY=dYY,constrain_isn=constrain_isn,tv=tv) # Wt[ihyper][itry] = [w[-1] for w in Wt_temp] # loss[ihyper,itry] = loss_temp[-1] def parse_W(W): Wmx,Wmy,Wsx,Wsy,s02,K,kappa,T,XX,XXp,Eta,Xi,h = W return Wmx,Wmy,Wsx,Wsy,s02,K,kappa,T,XX,XXp,Eta,Xi,h itry = 0 Wmx,Wmy,Wsx,Wsy,s02,K,kappa,T,XX,XXp,Eta,Xi,h = parse_W(Wt[0][0]) labels = ['Wmx','Wmy','Wsx','Wsy','s02','K','kappa','T','XX','XXp','Eta','Xi','h'] Wstar_dict = {} for i,label in enumerate(labels): Wstar_dict[label] = Wt[0][0][i] Wstar_dict['as_list'] = [Wmx,Wmy,Wsx,Wsy,s02,K,kappa,T,XX,XXp,Eta,Xi,h] Wstar_dict['loss'] = loss[0][0] Wstar_dict['wt_dict'] = wt_dict np.save(weights_file,Wstar_dict,allow_pickle=True)
def norm_to_mean(r): R = r.reshape((r.shape[0],-1)) R = R/np.nanmean(R[:,~np.isnan(R.sum(0))],axis=1)[:,np.newaxis] return R
def boxQP(H, g, lower, upper, x0): n = H.shape[0] clamped = np.zeros(n) free = np.ones(n) Hfree = np.zeros(n) oldvalue = 0 result = 0 nfactor = 0 clamp = lambda value: np.maximum(lower, np.minimum(upper, value)) maxIter = 100 minRelImprove = 1e-8 minGrad = 1e-8 stepDec = 0.6 minStep = 1e-22 Armijo = 0.1 if x0.shape[0] == n: x = clamp(x0) else: lu = np.array([lower, upper]) lu[np.isnan(lu)] = np.nan x = np.nanmean(lu, axis=1) value = np.dot(x.T, np.dot(H, x)) + np.dot(x.T, g) for iteration in range(maxIter): if result != 0: break if iteration > 1 and (oldvalue - value) < minRelImprove * abs(oldvalue): result = 4 logging.info("[QP info] Improvement smaller than tolerance") break oldvalue = value grad = g + np.dot(H, x) old_clamped = clamped clamped = np.zeros(n) clamped[np.logical_and(x == lower, grad > 0)] = 1 clamped[np.logical_and(x == upper, grad < 0)] = 1 free = np.logical_not(clamped) if np.all(clamped): result = 6 logging.info("[QP info] All dimensions are clamped") break if iteration == 0: factorize = True else: factorize = np.any(old_clamped != clamped) if factorize: try: if not np.all(np.allclose(H, H.T)): H = np.triu(H) Hfree = np.linalg.cholesky(H[np.ix_(free, free)]) except LinAlgError: eigs, _ = np.linalg.eig(H[np.ix_(free, free)]) print(eigs) result = -1 logging.info("[QP info] Hessian is not positive definite") break nfactor += 1 gnorm = np.linalg.norm(grad[free]) if gnorm < minGrad: result = 5 logging.info("[QP info] Gradient norm smaller than tolerance") break grad_clamped = g + np.dot(H, x*clamped) search = np.zeros(n) y = np.linalg.lstsq(Hfree.T, grad_clamped[free])[0] search[free] = -np.linalg.lstsq(Hfree, y)[0] - x[free] sdotg = np.sum(search*grad) if sdotg >= 0: print(f"[QP info] No descent direction found. Should not happen. Grad is {grad}") break # armijo linesearch step = 1 nstep = 0 xc = clamp(x + step*search) vc = np.dot(xc.T, g) + 0.5*np.dot(xc.T, np.dot(H, xc)) while (vc - oldvalue) / (step*sdotg) < Armijo: step *= stepDec nstep += 1 xc = clamp(x + step * search) vc = np.dot(xc.T, g) + 0.5 * np.dot(xc.T, np.dot(H, xc)) if step < minStep: result = 2 break # accept candidate x = xc value = vc # print(f"[QP info] Iteration {iteration}, value of the cost: {vc}") if iteration >= maxIter: result = 1 return x, result, Hfree, free
def fit_weights_and_save( weights_file, ca_data_file='rs_vm_denoise_200605.npy', opto_silencing_data_file='vip_halo_data_for_sim.npy', opto_activation_data_file='vip_chrimson_data_for_sim.npy', constrain_wts=None, allow_var=True, fit_s02=True, constrain_isn=True, tv=False, l2_penalty=0.01, init_noise=0.1, init_W_from_lsq=False, init_W_from_lbfgs=False, scale_init_by=1, init_W_from_file=False, init_file=None, correct_Eta=False, init_Eta_with_s02=False, init_Eta12_with_dYY=False, use_opto_transforms=False, share_residuals=False, stimwise=False, simulate1=True, simulate2=False, help_constrain_isn=True, ignore_halo_vip=False, verbose=True, free_amplitude=False, norm_opto_transforms=False, zero_extra_weights=None, allow_s2=True): nsize, ncontrast = 6, 6 npfile = np.load(ca_data_file, allow_pickle=True)[( )] #,{'rs':rs,'rs_denoise':rs_denoise},allow_pickle=True) rs = npfile['rs'] #rs_denoise = npfile['rs_denoise'] nsize, ncontrast, ndir = 6, 6, 8 #ori_dirs = [[0,4],[2,6]] #[[0,4],[1,3,5,7],[2,6]] ori_dirs = [[0, 1, 2, 3, 4, 5, 6, 7]] nT = len(ori_dirs) nS = len(rs[0]) def sum_to_1(r): R = r.reshape((r.shape[0], -1)) #R = R/np.nansum(R[:,~np.isnan(R.sum(0))],axis=1)[:,np.newaxis] R = R / np.nansum(R, axis=1)[:, np.newaxis] # changed 8/28 return R def norm_to_mean(r): R = r.reshape((r.shape[0], -1)) R = R / np.nanmean(R[:, ~np.isnan(R.sum(0))], axis=1)[:, np.newaxis] return R Rs = [[None, None] for i in range(len(rs))] Rso = [[[None for iT in range(nT)] for iS in range(nS)] for icelltype in range(len(rs))] rso = [[[None for iT in range(nT)] for iS in range(nS)] for icelltype in range(len(rs))] for iR, r in enumerate(rs): #rs_denoise): #print(iR) for ialign in range(nS): #Rs[iR][ialign] = r[ialign][:,:nsize,:] #sm = np.nanmean(np.nansum(np.nansum(Rs[iR][ialign],1),1)) #Rs[iR][ialign] = Rs[iR][ialign]/sm #print('frac isnan Rs %d,%d: %f'%(iR,ialign,np.isnan(r[ialign]).mean())) Rs[iR][ialign] = sum_to_1(r[ialign][:, :nsize, :]) # Rs[iR][ialign] = von_mises_denoise(Rs[iR][ialign].reshape((-1,nsize,ncontrast,ndir))) kernel = np.ones((1, 2, 2)) kernel = kernel / kernel.sum() for iR, r in enumerate(rs): for ialign in range(nS): for iori in range(nT): #print('this Rs shape: '+str(Rs[iR][ialign].shape)) #print('this Rs reshaped shape: '+str(Rs[iR][ialign].reshape((-1,nsize,ncontrast,ndir))[:,:,:,ori_dirs[iori]].shape)) #print('this Rs max percent nan: '+str(np.isnan(Rs[iR][ialign].reshape((-1,nsize,ncontrast,ndir))[:,:,:,ori_dirs[iori]]).mean(-1).max())) Rso[iR][ialign][iori] = np.nanmean( Rs[iR][ialign].reshape( (-1, nsize, ncontrast, ndir))[:, :, :, ori_dirs[iori]], -1) Rso[iR][ialign][iori][:, :, 0] = np.nanmean( Rso[iR][ialign][iori][:, :, 0], 1)[:, np.newaxis] # average 0 contrast values #print('frac isnan pre-conv Rso %d,%d,%d: %f'%(iR,ialign,iori,np.isnan(Rso[iR][ialign][iori]).mean())) Rso[iR][ialign][iori][:, 1:, 1:] = ssi.convolve( Rso[iR][ialign][iori], kernel, 'valid') Rso[iR][ialign][iori] = Rso[iR][ialign][iori].reshape( Rso[iR][ialign][iori].shape[0], -1) #print('frac isnan Rso %d,%d,%d: %f'%(iR,ialign,iori,np.isnan(Rso[iR][ialign][iori]).mean())) #print('sum of Rso isnan: '+str(np.isnan(Rso[iR][ialign][iori]).sum(1))) #Rso[iR][ialign][iori] = Rso[iR][ialign][iori]/np.nanmean(Rso[iR][ialign][iori],-1)[:,np.newaxis] def set_bound(bd, code, val=0): # set bounds to 0 where 0s occur in 'code' for iitem in range(len(bd)): bd[iitem][code[iitem]] = val nN = 36 nS = 2 nP = 2 nT = 1 nQ = 4 # code for bounds: 0 , constrained to 0 # +/-1 , constrained to +/-1 # 1.5, constrained to [0,1] # 2 , constrained to [0,inf) # -2 , constrained to (-inf,0] # 3 , unconstrained Wmx_bounds = 3 * np.ones((nP, nQ), dtype=int) Wmx_bounds[0, :] = 2 # L4 PCs are excitatory Wmx_bounds[0, 1] = 0 # SSTs don't receive L4 input if allow_var: Wsx_bounds = 3 * np.ones( Wmx_bounds.shape) #Wmx_bounds.copy()*0 #np.zeros_like(Wmx_bounds) Wsx_bounds[0, 1] = 0 else: Wsx_bounds = np.zeros( Wmx_bounds.shape) #Wmx_bounds.copy()*0 #np.zeros_like(Wmx_bounds) Wmy_bounds = 3 * np.ones((nQ, nQ), dtype=int) Wmy_bounds[0, :] = 2 # PCs are excitatory Wmy_bounds[1:, :] = -2 # all the cell types except PCs are inhibitory Wmy_bounds[1, 1] = 0 # SSTs don't inhibit themselves # Wmy_bounds[3,1] = 0 # PVs are allowed to inhibit SSTs, consistent with Hillel's unpublished results, but not consistent with Pfeffer et al. Wmy_bounds[ 2, 0] = 0 # VIPs don't inhibit L2/3 PCs. According to Pfeffer et al., only L5 PCs were found to get VIP inhibition if not zero_extra_weights is None: Wmx_bounds[zero_extra_weights[0]] = 0 Wmy_bounds[zero_extra_weights[1]] = 0 if allow_var: Wsy_bounds = 3 * np.ones( Wmy_bounds.shape) #Wmy_bounds.copy()*0 #np.zeros_like(Wmy_bounds) Wsy_bounds[1, 1] = 0 Wsy_bounds[3, 1] = 0 Wsy_bounds[2, 0] = 0 else: Wsy_bounds = np.zeros( Wmy_bounds.shape) #Wmy_bounds.copy()*0 #np.zeros_like(Wmy_bounds) if not constrain_wts is None: for wt in constrain_wts: Wmy_bounds[wt[0], wt[1]] = 0 Wsy_bounds[wt[0], wt[1]] = 0 def tile_nS_nT_nN(kernel): row = np.concatenate([kernel for idim in range(nS * nT)], axis=0)[np.newaxis, :] tiled = np.concatenate([row for irow in range(nN)], axis=0) return tiled def set_bounds_by_code(lb, ub, bdlist): set_bound(lb, [bd == 0 for bd in bdlist], val=0) set_bound(ub, [bd == 0 for bd in bdlist], val=0) set_bound(lb, [bd == 2 for bd in bdlist], val=0) set_bound(ub, [bd == -2 for bd in bdlist], val=0) set_bound(lb, [bd == 1 for bd in bdlist], val=1) set_bound(ub, [bd == 1 for bd in bdlist], val=1) set_bound(lb, [bd == 1.5 for bd in bdlist], val=0) set_bound(ub, [bd == 1.5 for bd in bdlist], val=1) set_bound(lb, [bd == -1 for bd in bdlist], val=-1) set_bound(ub, [bd == -1 for bd in bdlist], val=-1) if allow_s2: if fit_s02: s02_bounds = 2 * np.ones( (nQ, )) # permitting noise as a free parameter else: s02_bounds = np.ones((nQ, )) else: s02_bounds = np.zeros((nQ, )) k_bounds = 1.5 * np.ones((nQ * (nS - 1), )) #k_bounds[1] = 0 # temporary: spatial kernel constrained to 0 for SST #k_bounds[2] = 0 # temporary: spatial kernel constrained to 0 for VIP kappa_bounds = np.ones((1, )) # kappa_bounds = 2*np.ones((1,)) T_bounds = 1.5 * np.ones((nQ * (nT - 1), )) X_bounds = tile_nS_nT_nN(np.array([2, 1])) # X_bounds = np.array([np.array([2,1,2,1])]*nN) Xp_bounds = tile_nS_nT_nN(np.array([3, 1])) # Xp_bounds = np.array([np.array([3,1,3,1])]*nN) # Y_bounds = tile_nS_nT_nN(2*np.ones((nQ,))) # # Y_bounds = 2*np.ones((nN,nT*nS*nQ)) Eta_bounds = tile_nS_nT_nN(3 * np.ones((nQ, ))) # Eta_bounds = 3*np.ones((nN,nT*nS*nQ)) if allow_s2: if allow_var: Xi_bounds = tile_nS_nT_nN(3 * np.ones((nQ, ))) else: Xi_bounds = tile_nS_nT_nN(np.zeros((nQ, ))) else: Xi_bounds = tile_nS_nT_nN(np.zeros((nQ, ))) # Xi_bounds = 3*np.ones((nN,nT*nS*nQ)) h1_bounds = -2 * np.ones((1, )) h2_bounds = 2 * np.ones((1, )) bl_bounds = 3 * np.ones((nQ, )) if free_amplitude: amp_bounds = 2 * np.ones((nT * nS * nQ, )) else: amp_bounds = 1 * np.ones((nT * nS * nQ, )) # shapes = [(nP,nQ),(nQ,nQ),(nP,nQ),(nQ,nQ),(nQ,),(nQ,),(1,),(nN,nS*nP),(nN,nS*nQ),(nN,nS*nQ),(nN,nS*nQ)] shapes1 = [(nP, nQ), (nQ, nQ), (nP, nQ), (nQ, nQ), (nQ, ), (nQ * (nS - 1), ), (1, ), (nQ * (nT - 1), ), (1, ), (1, ), (nQ, ), (nQ * nS * nT, )] shapes2 = [(nN, nT * nS * nP), (nN, nT * nS * nP), (nN, nT * nS * nQ), (nN, nT * nS * nQ)] #print('size of shapes1: '+str(np.sum([np.prod(shp) for shp in shapes1]))) #print('size of shapes2: '+str(np.sum([np.prod(shp) for shp in shapes2]))) # Wmx, Wmy, Wsx, Wsy, s02, k, kappa,T, h1, h2 #XX, XXp, Eta, Xi #bdlist = [Wmx_bounds,Wmy_bounds,Wsx_bounds,Wsy_bounds,s02_bounds,k_bounds,kappa_bounds,T_bounds,X_bounds,Xp_bounds,Eta_bounds,Xi_bounds,h1_bounds,h2_bounds] bd1list = [ Wmx_bounds, Wmy_bounds, Wsx_bounds, Wsy_bounds, s02_bounds, k_bounds, kappa_bounds, T_bounds, h1_bounds, h2_bounds, bl_bounds, amp_bounds ] bd2list = [X_bounds, Xp_bounds, Eta_bounds, Xi_bounds] lb1, ub1 = [[sgn * np.inf * np.ones(shp) for shp in shapes1] for sgn in [-1, 1]] set_bounds_by_code(lb1, ub1, bd1list) lb2, ub2 = [[sgn * np.inf * np.ones(shp) for shp in shapes2] for sgn in [-1, 1]] set_bounds_by_code(lb2, ub2, bd2list) #set_bound(lb,[bd==0 for bd in bdlist],val=0) #set_bound(ub,[bd==0 for bd in bdlist],val=0) # #set_bound(lb,[bd==2 for bd in bdlist],val=0) # #set_bound(ub,[bd==-2 for bd in bdlist],val=0) # #set_bound(lb,[bd==1 for bd in bdlist],val=1) #set_bound(ub,[bd==1 for bd in bdlist],val=1) # #set_bound(lb,[bd==1.5 for bd in bdlist],val=0) #set_bound(ub,[bd==1.5 for bd in bdlist],val=1) # #set_bound(lb,[bd==-1 for bd in bdlist],val=-1) #set_bound(ub,[bd==-1 for bd in bdlist],val=-1) # for bd in [lb,ub]: # for ind in [2,3]: # bd[ind][:,1] = 0 # temporary for no variation expt. # lb[2] = np.zeros_like(lb[2]) # lb[3] = np.zeros_like(lb[3]) # lb[4] = np.ones_like(lb[4]) # lb[5] = np.zeros_like(lb[5]) # ub[2] = np.zeros_like(ub[2]) # ub[3] = np.zeros_like(ub[3]) # ub[4] = np.ones_like(ub[4]) # ub[5] = np.ones_like(ub[5]) # temporary for no variation expt. lb1 = np.concatenate([a.flatten() for a in lb1]) ub1 = np.concatenate([b.flatten() for b in ub1]) lb2 = np.concatenate([a.flatten() for a in lb2]) ub2 = np.concatenate([b.flatten() for b in ub2]) bounds1 = [(a, b) for a, b in zip(lb1, ub1)] bounds2 = [(a, b) for a, b in zip(lb2, ub2)] nS = 2 #print('nT: '+str(nT)) ndims = 5 ncelltypes = 5 Yhat = [[None for iT in range(nT)] for iS in range(nS)] Xhat = [[None for iT in range(nT)] for iS in range(nS)] Ypc_list = [[None for iT in range(nT)] for iS in range(nS)] Xpc_list = [[None for iT in range(nT)] for iS in range(nS)] mx = [None for iS in range(nS)] for iS in range(nS): mx[iS] = np.zeros((ncelltypes, )) yy = [None for icelltype in range(ncelltypes)] for icelltype in range(ncelltypes): yy[icelltype] = np.nanmean(Rso[icelltype][iS][0], 0) mx[iS][icelltype] = np.nanmax(yy[icelltype]) for iT in range(nT): y = [ np.nanmean(Rso[icelltype][iS][iT], axis=0)[:, np.newaxis] / mx[iS][icelltype] for icelltype in range(1, ncelltypes) ] Ypc_list[iS][iT] = [None for icelltype in range(1, ncelltypes)] for icelltype in range(1, ncelltypes): # as currently written, penalties involving (X,Y)pc_list are effectively artificially smaller by # a factor of mx[iS][icelltype] compared to what one would expect from the (X,Y)-penalty as defined # subsequently. rss = Rso[icelltype][iS][iT].copy( ) #/mx[iS][icelltype] #.reshape(Rs[icelltype][ialign].shape[0],-1) #print('sum of isnan: '+str(np.isnan(rss).sum(1))) #rss = Rso[icelltype][iS][iT].copy() #.reshape(Rs[icelltype][ialign].shape[0],-1) rss = rss[np.isnan(rss).sum(1) == 0] # print(rss.max()) # rss[rss<0] = 0 # rss = rss[np.random.randn(rss.shape[0])>0] try: u, s, v = np.linalg.svd(rss - np.mean(rss, 0)[np.newaxis]) Ypc_list[iS][iT][icelltype - 1] = [ (s[idim], v[idim]) for idim in range(ndims) ] # print('yep on Y') # print(np.min(np.sum(rs[icelltype][iS][iT],axis=1))) except: print('nope on Y') #print('shape of rss: '+str(rss.shape)) #print('mean of rss: '+str(np.mean(np.isnan(rss)))) #print('min of this rs: '+str(np.min(np.sum(rs[icelltype][iS][iT],axis=1)))) Yhat[iS][iT] = np.concatenate(y, axis=1) # x = sim_utils.columnize(Rso[0][iS][iT])[:,np.newaxis] icelltype = 0 #x = np.nanmean(Rso[icelltype][iS][iT],0)[:,np.newaxis]#/mx[iS][icelltype] x = np.nanmean(Rso[icelltype][iS][iT], 0)[:, np.newaxis] / mx[iS][icelltype] # opto_column = np.concatenate((np.zeros((nN,)),np.zeros((nNO/2,)),np.ones((nNO/2,))),axis=0)[:,np.newaxis] Xhat[iS][iT] = np.concatenate((x, np.ones_like(x)), axis=1) # Xhat[iS][iT] = np.concatenate((x,np.ones_like(x),opto_column),axis=1) icelltype = 0 #rss = Rso[icelltype][iS][iT].copy()/mx[iS][icelltype] rss = Rso[icelltype][iS][iT].copy() rss = rss[np.isnan(rss).sum(1) == 0] # try: u, s, v = np.linalg.svd(rss - rss.mean(0)[np.newaxis]) Xpc_list[iS][iT] = [None for iinput in range(2)] Xpc_list[iS][iT][0] = [(s[idim], v[idim]) for idim in range(ndims)] Xpc_list[iS][iT][1] = [(0, np.zeros((Xhat[0][0].shape[0], ))) for idim in range(ndims)] # except: # print('nope on X') # print(np.mean(np.isnan(rss))) # print(np.min(np.sum(Rso[icelltype][iS][iT],axis=1))) nN, nP = Xhat[0][0].shape #print('nP: '+str(nP)) nQ = Yhat[0][0].shape[1] import sim_utils pop_rate_fn = sim_utils.f_miller_troyer pop_deriv_fn = sim_utils.fprime_miller_troyer def compute_f_(Eta, Xi, s02): return sim_utils.f_miller_troyer( Eta, Xi**2 + np.concatenate([s02 for ipixel in range(nS * nT)])) def compute_fprime_m_(Eta, Xi, s02): return sim_utils.fprime_miller_troyer( Eta, Xi**2 + np.concatenate([s02 for ipixel in range(nS * nT)])) * Xi def compute_fprime_s_(Eta, Xi, s02): s2 = Xi**2 + np.concatenate((s02, s02), axis=0) return sim_utils.fprime_s_miller_troyer(Eta, s2) * (Xi / s2) def sorted_r_eigs(w): drW, prW = np.linalg.eig(w) srtinds = np.argsort(drW) return drW[srtinds], prW[:, srtinds] # 0.Wmx, 1.Wmy, 2.Wsx, 3.Wsy, 4.s02,5.K, 6.kappa,7.T,8.XX, 9.XXp, 10.Eta, 11.Xi, 12.h1, 13.h2 shapes1 = [(nP, nQ), (nQ, nQ), (nP, nQ), (nQ, nQ), (nQ, ), (nQ * (nS - 1), ), (1, ), (nQ * (nT - 1), ), (1, ), (1, ), (nQ, ), (nT * nS * nQ, )] shapes2 = [(nN, nT * nS * nP), (nN, nT * nS * nP), (nN, nT * nS * nQ), (nN, nT * nS * nQ)] #print('size of shapes1: '+str(np.sum([np.prod(shp) for shp in shapes1]))) #print('size of shapes2: '+str(np.sum([np.prod(shp) for shp in shapes2]))) import calnet.fitting_spatial_feature YYhat = calnet.utils.flatten_nested_list_of_2d_arrays(Yhat) XXhat = calnet.utils.flatten_nested_list_of_2d_arrays(Xhat) opto_dict = np.load(opto_silencing_data_file, allow_pickle=True)[()] Yhat_opto = opto_dict['Yhat_opto'] Yhat_opto = np.nanmean(np.reshape(Yhat_opto, (nN, 2, nS, 2, nQ)), 3).reshape((nN * 2, -1)) Yhat_opto[0::12] = np.nanmean(Yhat_opto[0::12], axis=0)[np.newaxis] Yhat_opto[1::12] = np.nanmean(Yhat_opto[1::12], axis=0)[np.newaxis] Yhat_opto = Yhat_opto / np.nanmax(Yhat_opto[0::2], 0)[np.newaxis, :] #print(Yhat_opto.shape) h_opto = opto_dict['h_opto'] #dYY1 = Yhat_opto[1::2]-Yhat_opto[0::2] YYhat_halo = Yhat_opto.reshape((nN, 2, -1)) opto_transform1 = calnet.utils.fit_opto_transform( YYhat_halo, norm01=norm_opto_transforms) opto_transform1.res[:, [0, 2, 3, 4, 6, 7]] = 0 dYY1 = opto_transform1.transform(YYhat) - opto_transform1.preprocess(YYhat) #YYhat_halo_sim = calnet.utils.simulate_opto_effect(YYhat,YYhat_halo) #dYY1 = YYhat_halo_sim[:,1,:] - YYhat_halo_sim[:,0,:] def overwrite_plus_n(arr, to_overwrite, n): arr[:, to_overwrite] = arr[:, int(to_overwrite + n)] return arr for to_overwrite in [1, 2]: n = 4 dYY1,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res \ = [overwrite_plus_n(x,to_overwrite,n) for x in \ [dYY1,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res]] for to_overwrite in [7]: n = -4 dYY1,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res \ = [overwrite_plus_n(x,to_overwrite,n) for x in \ [dYY1,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res]] if ignore_halo_vip: dYY1[:, 2::nQ] = np.nan #for to_overwrite in [1,2]: # dYY1[:,to_overwrite] = dYY1[:,to_overwrite+4] #for to_overwrite in [7]: # dYY1[:,to_overwrite] = dYY1[:,to_overwrite-4] #Yhat_opto = opto_dict['Yhat_opto'] #for iS in range(nS): # mx = np.zeros((nQ,)) # for iQ in range(nQ): # slicer = slice(nQ*nT*iS+iQ,nQ*nT*(1+iS),nQ) # mx[iQ] = np.nanmax(Yhat_opto[0::2][:,slicer]) # Yhat_opto[:,slicer] = Yhat_opto[:,slicer]/mx[iQ] ##Yhat_opto = Yhat_opto/Yhat_opto[0::2].max(0)[np.newaxis,:] #print(Yhat_opto.shape) #h_opto = opto_dict['h_opto'] #dYY1 = Yhat_opto[1::2]-Yhat_opto[0::2] #for to_overwrite in [1,2,5,6]: # overwrite sst and vip with off-centered values # dYY1[:,to_overwrite] = dYY1[:,to_overwrite+8] #for to_overwrite in [11,15]: # dYY1[:,to_overwrite] = np.nan #dYY1[:,to_overwrite-8] opto_dict = np.load(opto_activation_data_file, allow_pickle=True)[()] Yhat_opto = opto_dict['Yhat_opto'] Yhat_opto = np.nanmean(np.reshape(Yhat_opto, (nN, 2, nS, 2, nQ)), 3).reshape((nN * 2, -1)) Yhat_opto[0::12] = np.nanmean(Yhat_opto[0::12], axis=0)[np.newaxis] Yhat_opto[1::12] = np.nanmean(Yhat_opto[1::12], axis=0)[np.newaxis] Yhat_opto = Yhat_opto / Yhat_opto[0::2].max(0)[np.newaxis, :] #print(Yhat_opto.shape) h_opto = opto_dict['h_opto'] #dYY2 = Yhat_opto[1::2]-Yhat_opto[0::2] YYhat_chrimson = Yhat_opto.reshape((nN, 2, -1)) opto_transform2 = calnet.utils.fit_opto_transform( YYhat_chrimson, norm01=norm_opto_transforms) dYY2 = opto_transform2.transform(YYhat) - opto_transform2.preprocess(YYhat) #YYhat_chrimson_sim = calnet.utils.simulate_opto_effect(YYhat,YYhat_chrimson) #dYY2 = YYhat_chrimson_sim[:,1,:] - YYhat_chrimson_sim[:,0,:] #Yhat_opto = opto_dict['Yhat_opto'] #for iS in range(nS): # mx = np.zeros((nQ,)) # for iQ in range(nQ): # slicer = slice(nQ*nT*iS+iQ,nQ*nT*(1+iS),nQ) # mx[iQ] = np.nanmax(Yhat_opto[0::2][:,slicer]) # Yhat_opto[:,slicer] = Yhat_opto[:,slicer]/mx[iQ] ##Yhat_opto = Yhat_opto/Yhat_opto[0::2].max(0)[np.newaxis,:] #print(Yhat_opto.shape) #h_opto = opto_dict['h_opto'] #dYY2 = Yhat_opto[1::2]-Yhat_opto[0::2] #print('dYY1 mean: %03f'%np.nanmean(np.abs(dYY1))) #print('dYY2 mean: %03f'%np.nanmean(np.abs(dYY2))) dYY = np.concatenate((dYY1, dYY2), axis=0) #titles = ['VIP silencing','VIP activation'] #for itype in [0,1,2,3]: # plt.figure(figsize=(5,2.5)) # for iyy,dyy in enumerate([dYY1,dYY2]): # plt.subplot(1,2,iyy+1) # if np.sum(np.isnan(dyy[:,itype]))==0: # sca.scatter_size_contrast(YYhat[:,itype],YYhat[:,itype]+dyy[:,itype],nsize=6,ncontrast=6)#,mn=0) # plt.title(titles[iyy]) # plt.xlabel('cell type %d event rate, \n light off'%itype) # plt.ylabel('cell type %d event rate, \n light on'%itype) # ut.erase_top_right() # plt.tight_layout() # ut.mkdir('figures') # plt.savefig('figures/scatter_light_on_light_off_target_celltype_%d.eps'%itype) opto_mask = ~np.isnan(dYY) #dYY[nN:][~opto_mask[nN:]] = -dYY[:nN][~opto_mask[nN:]] #print('mean of opto_mask: '+str(opto_mask.mean())) #dYY[~opto_mask] = 0 def zero_nans(arr): arr[np.isnan(arr)] = 0 return arr #dYY,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res,\ # opto_transform2.slope,opto_transform2.intercept,opto_transform2.res\ # = [zero_nans(x) for x in \ # [dYY,opto_transform1.slope,opto_transform1.intercept,opto_transform1.res,\ # opto_transform2.slope,opto_transform2.intercept,opto_transform2.res]] dYY = zero_nans(dYY) to_adjust = np.logical_or(np.isnan(opto_transform2.slope[0]), np.isnan(opto_transform2.intercept[0])) opto_transform2.slope[:, to_adjust] = 1 / opto_transform1.slope[:, to_adjust] opto_transform2.intercept[:, to_adjust] = -opto_transform1.intercept[:, to_adjust] / opto_transform1.slope[:, to_adjust] opto_transform2.res[:, to_adjust] = -opto_transform1.res[:, to_adjust] / opto_transform1.slope[:, to_adjust] #np.save('/Users/dan/Documents/notebooks/mossing-PC/shared_data/calnet_data/dYY.npy',dYY) from importlib import reload reload(calnet) #reload(calnet.fitting_2step_spatial_feature_opto_tight_nonlinear) reload(sim_utils) # reload(calnet.fitting_spatial_feature) # W0list = [np.ones(shp) for shp in shapes] wt_dict = {} wt_dict['X'] = 3 #1 wt_dict['Y'] = 3 #wt_dict['Eta'] = 3 # 1 # wt_dict['Xi'] = 0.1 wt_dict['stims'] = np.ones((nN, 1)) #(np.arange(30)/30)[:,np.newaxis]**1 # wt_dict['barrier'] = 0. #30.0 #0.1 wt_dict['opto'] = 1 #1e1 wt_dict['isn'] = 0.3 wt_dict['tv'] = 1 spont_frac = 0.5 pc_frac = 0.5 wt_dict['stimsOpto'] = (1 - spont_frac) * 6 / 5 * np.ones((nN, 1)) wt_dict['stimsOpto'][0::6] = spont_frac * 6 wt_dict['celltypesOpto'] = (1 - pc_frac) * 4 / 3 * np.ones( (1, nQ * nS * nT)) wt_dict['celltypesOpto'][0, 0::nQ] = pc_frac * 4 wt_dict['dirOpto'] = np.array((1, 0.3)) wt_dict['dYY'] = 10 #10 wt_dict['coupling'] = 1e-3 wt_dict['smi'] = 0.1 wt_dict['smi_halo'] = 30 wt_dict['smi_chrimson'] = 0.1 ##temporary no_opto wt_dict['opto'] = 0 wt_dict['dirOpto'] = np.array((1, 1)) #wt_dict['stimsOpto'] = np.ones((nN,1)) wt_dict['celltypesOpto'] = np.ones((1, nQ * nS * nT)) wt_dict['smi'] = 0 #0.01 # 0 wt_dict['smi_halo'] = 0 #1 # 0 wt_dict['smi_chrimson'] = 0 #0.01 # 0 wt_dict['isn'] = 0.1 wt_dict['tv'] = 0.1 wt_dict['X'] = 3 wt_dict['Eta'] = 10 #3 # 1 # ## temporary opto from no_opto #wt_dict['opto'] = 0.01 #wt_dict['tv'] = 0.3#0.1 np.save( 'XXYYhat.npy', { 'YYhat': YYhat, 'XXhat': XXhat, 'rs': rs, 'Rs': Rs, 'Rso': Rso, 'Ypc_list': Ypc_list, 'Xpc_list': Xpc_list }) if allow_s2: Eta0 = invert_f_mt(YYhat) else: Eta0 = invert_f_mt(YYhat, s02=0) # Wmx, Wmy, Wsx, Wsy, s02, k, kappa,T, h1, h2 #XX, XXp, Eta, Xi opt = fmc.gen_opt(nS=nS, nT=nT) opt['allow_s02'] = False opt['allow_A'] = False opt['allow_B'] = True ntries = 1 nhyper = 1 dt = 1e-1 niter = int(np.round(10 / dt)) #int(1e4) perturbation_size = 5e-2 # learning_rate = 1e-4 # 1e-5 #np.linspace(3e-4,1e-3,niter+1) # 1e-5 #l2_penalty = 0.1 W1t = [[None for itry in range(ntries)] for ihyper in range(nhyper)] W2t = [[None for itry in range(ntries)] for ihyper in range(nhyper)] loss = np.zeros((nhyper, ntries)) is_neg = np.array([b[1] for b in bounds1]) == 0 counter = 0 negatize = [np.zeros(shp, dtype='bool') for shp in shapes1] #print(shapes1) for ishp, shp in enumerate(shapes1): nel = np.prod(shp) negatize[ishp][:][is_neg[counter:counter + nel].reshape(shp)] = True counter = counter + nel for ihyper in range(nhyper): for itry in range(ntries): #print((ihyper,itry)) #[0.(nP,nQ),1.(nQ,nQ),2.(nP,nQ),3.(nQ,nQ),4.(nQ,),5.(nQ*(nS-1),),6.(1,),7.(nQ*(nT-1),),8.(1,),9.(1,),10.(nQ,),11.(nQ*nS*nT,)] W10list = [ init_noise * (ihyper + 1) * np.random.rand(*shp) for shp in shapes1 ] W20list = [ init_noise * (ihyper + 1) * np.random.rand(*shp) for shp in shapes2 ] #print('size of shapes1: '+str(np.sum([np.prod(shp) for shp in shapes1]))) #print('size of w10: '+str(np.sum([np.size(x) for x in W10list]))) #print('len(W10list) : '+str(len(W10list))) counter = 0 for ishp, shp in enumerate(shapes1): W10list[ishp][negatize[ishp]] = -W10list[ishp][negatize[ishp]] W10list[4] = np.ones(shapes1[4]) # s02 W10list[5] = np.ones(shapes1[5]) # K W10list[6] = np.ones(shapes1[6]) # kappa W10list[7] = np.ones(shapes1[7]) # T W10list[8] = np.zeros(shapes1[8]) # h1 W10list[9] = np.zeros(shapes1[9]) # h2 W10list[10] = np.zeros(shapes1[10]) # baseline W10list[11] = np.ones(shapes1[11]) # amplitude W20list[0] = np.concatenate(Xhat, axis=1) #XX W20list[1] = np.zeros_like(W20list[1]) #XXp W20list[2] = Eta0.copy() #np.zeros(shapes[10]) #Eta W20list[3] = np.zeros(shapes2[3]) #Xi #[Wmx,Wmy,Wsx,Wsy,s02,k,kappa,T,XX,XXp,Eta,Xi] if init_W_from_lsq: W10list[0], W10list[1] = initialize_W(Xhat, Yhat, scale_by=scale_init_by, allow_s2=allow_s2) for ivar in range(0, 2): W10list[ ivar] = W10list[ivar] + init_noise * np.random.randn( *W10list[ivar].shape) if init_W_from_lbfgs: print(opt) opt_param, result, _, _, _, _, _, _, _, _, _, _, _ = fmc.initialize_params( XXhat, YYhat, opt, wpcpc=5, wpvpv=-6) these_shapes = [(nP, nQ), (nQ, nQ), (nQ, ), (nQ, ), (nQ, ), (nQ, )] Wmx0, Wmy0, K0, s020, amplitude0, baseline0 = calnet.utils.parse_thing( opt_param, these_shapes) if init_Eta_with_s02: #assert(True==False) Eta0 = invert_f_mt_with_s02(YYhat - np.tile(baseline0, nS * nT), s020, nS=nS, nT=nT) W20list[2] = Eta0.copy() #Wmx0 = opt_param[:nP] #Wmy0 = opt_param[nP:nP+nQ] #K0 = opt_param[nP+nQ] #s020 = opt_param[nP+nQ+1] #amplitude0 = opt_param[nP+nQ+2] #baseline0 = opt_param[nP+nQ+3] print((Wmx0, Wmy0, K0, s020, np.tile(amplitude0, 2), baseline0)) W10list[0], W10list[1], W10list[5], W10list[4], W10list[ -1], W10list[-2] = Wmx0, Wmy0, K0, s020, np.tile( amplitude0, 2), baseline0 for ivar in range(0, 2): W10list[ ivar] = W10list[ivar] + init_noise * np.random.randn( *W10list[ivar].shape) elif constrain_isn: W10list[1][0, 0] = 3 if help_constrain_isn: W10list[1][0, 3] = 5 W10list[1][3, 0] = -5 W10list[1][3, 3] = -5 else: W10list[1][0, 1:4] = 5 W10list[1][1:4, 0] = -5 if init_W_from_file: npyfile = np.load(init_file, allow_pickle=True)[()] #Wmx,Wmy,Wsx,Wsy,s02,K,kappa,T,h1,h2,bl,amp = parse_W1(W1) #XX,XXp,Eta,Xi = parse_W2(W2) #Wmx,Wmy,Wsx,Wsy,s02,K,kappa,T,XX,XXp,Eta,Xi,h1,h2,bl,amp = parse_W1(W1) W10list = [ npyfile['as_list'][ivar] for ivar in [0, 1, 2, 3, 4, 5, 6, 7, 12, 13, 14, 15] ] W20list = [npyfile['as_list'][ivar] for ivar in [8, 9, 10, 11]] if W20list[0].size == nN * nS * 2 * nP: #assert(True==False) W10list[7] = np.array(()) W10list[1][1, 0] = W10list[1][1, 0] W20list[0] = np.nanmean( W20list[0].reshape((nN, nS, 2, nP)), 2).flatten() #XX W20list[1] = np.nanmean( W20list[1].reshape((nN, nS, 2, nP)), 2).flatten() #XXp W20list[2] = np.nanmean( W20list[2].reshape((nN, nS, 2, nQ)), 2).flatten() #Eta W20list[3] = np.nanmean( W20list[3].reshape((nN, nS, 2, nQ)), 2).flatten() #Xi if correct_Eta: #assert(True==False) W20list[2] = Eta0.copy() if len(W10list) < len(shapes1): #assert(True==False) W10list = W10list + [ np.array(1), np.zeros((nQ, )), np.zeros((nT * nS * nQ, )) ] # add h2, bl, amp if init_Eta_with_s02: #assert(True==False) s02 = W10list[4].copy() Eta0 = invert_f_mt_with_s02(YYhat, s02, nS=nS, nT=nT) W20list[2] = Eta0.copy() #if init_Eta12_with_dYY: # Eta0 = W20list[2].copy().reshape((nN,nQ*nS*nT)) # Xi0 = W20list[3].copy().reshape((nN,nQ*nS*nT)) # s020 = W10list[4].copy() # YY0s = compute_f_(Eta0,Xi0,s020) #titles = ['VIP silencing','VIP activation'] #for itype in [0,1,2,3]: # plt.figure(figsize=(5,2.5)) # for iyy,yy in enumerate([YY10s,YY20s]): # plt.subplot(1,2,iyy+1) # if np.sum(np.isnan(yy[:,itype]))==0: # sca.scatter_size_contrast(YY0s[:,itype],yy[:,itype],nsize=6,ncontrast=6)#,mn=0) # plt.title(titles[iyy]) # plt.xlabel('cell type %d event rate, \n light off'%itype) # plt.ylabel('cell type %d event rate, \n light on'%itype) # ut.erase_top_right() # plt.tight_layout() # ut.mkdir('figures') # plt.savefig('figures/scatter_light_on_light_off_init_celltype_%d.eps'%itype) for ivar in [0, 1, 4, 5]: # Wmx, Wmy, s02, k print(init_noise) W10list[ ivar] = W10list[ivar] + init_noise * np.random.randn( *W10list[ivar].shape) #print('size of bounds1: '+str(np.sum([np.size(x) for x in bd1list]))) #print('size of w10: '+str(np.sum([np.size(x) for x in W10list]))) #print('size of shapes1: '+str(np.sum([np.prod(shp) for shp in shapes1]))) W1t[ihyper][itry], W2t[ihyper][itry], loss[ihyper][ itry], gr, hess, result = calnet.fitting_2step_spatial_feature_opto_tight_nonlinear_baseline.fit_W_sim( Xhat, Xpc_list, Yhat, Ypc_list, pop_rate_fn=pop_rate_fn, pop_deriv_fn=pop_deriv_fn, W10list=W10list.copy(), W20list=W20list.copy(), bounds1=bounds1, bounds2=bounds2, niter=niter, wt_dict=wt_dict, l2_penalty=l2_penalty, compute_hessian=False, dt=dt, perturbation_size=perturbation_size, dYY=dYY, constrain_isn=constrain_isn, tv=tv, opto_mask=opto_mask, use_opto_transforms=use_opto_transforms, opto_transform1=opto_transform1, opto_transform2=opto_transform2, share_residuals=share_residuals, stimwise=stimwise, simulate1=simulate1, simulate2=simulate2, verbose=verbose) #def parse_W(W): # Wmx,Wmy,Wsx,Wsy,s02,K,kappa,T,XX,XXp,Eta,Xi,h1,h2 = W # return Wmx,Wmy,Wsx,Wsy,s02,K,kappa,T,XX,XXp,Eta,Xi,h1,h2 def parse_W1(W): Wmx, Wmy, Wsx, Wsy, s02, K, kappa, T, h1, h2, bl, amp = W return Wmx, Wmy, Wsx, Wsy, s02, K, kappa, T, h1, h2, bl, amp def parse_W2(W): XX, XXp, Eta, Xi = W return XX, XXp, Eta, Xi itry = 0 Wmx, Wmy, Wsx, Wsy, s02, K, kappa, T, h1, h2, bl, amp = parse_W1(W1t[0][0]) XX, XXp, Eta, Xi = parse_W2(W2t[0][0]) labels1 = [ 'Wmx', 'Wmy', 'Wsx', 'Wsy', 's02', 'K', 'kappa', 'T', 'h1', 'h2', 'bl', 'amp' ] labels2 = ['XX', 'XXp', 'Eta', 'Xi'] Wstar_dict = {} for i, label in enumerate(labels1): Wstar_dict[label] = W1t[0][0][i] for i, label in enumerate(labels2): Wstar_dict[label] = W2t[0][0][i] Wstar_dict['as_list'] = [ Wmx, Wmy, Wsx, Wsy, s02, K, kappa, T, XX, XXp, Eta, Xi, h1, h2, bl, amp ] Wstar_dict['loss'] = loss[0][0] Wstar_dict['wt_dict'] = wt_dict np.save(weights_file, Wstar_dict, allow_pickle=True)
def get_rotation_gp(t, y, yerr, period, min_period, max_period): kernel = get_basic_kernel(t, y, yerr, period) kernel += get_rotation_kernel(t, y, yerr, period, min_period, max_period) gp = celerite.GP(kernel=kernel, mean=np.nanmean(y)) gp.compute(t) return gp