def compute_func_values(cell, theta, model, fobj, f, options, istrain): ''' Compute the objective function value, correlation, explained variance Outputs ------- fun (double): objective value cc (double): correlation coefficient ev (double): explained variance ''' if istrain: data = ccls.get_data(cell, model, options) else: temp_options = {} for key in options.keys(): if key == 'crossval': temp_options[key] = False else: temp_options[key] = options[key] data = ccls.get_data(cell, model, temp_options) options['basis'] = lnks.LinearFilterBasis_8param() options['stim'] = data[0] - np.mean(data[0]) if options['is_grad']: fun, grad = fobj(theta, data[0], data[1], options) else: fun = fobj(theta, data[0], data[1], options) if model.lower() == 'lnks_mp': y = data[1][1] v, y_est = f(theta, data[0], options) else: y = data[1] y_est = f(theta, data[0], options) if istrain: cc = stats.corrcoef(y, y_est) ev = stats.variance_explained(y, y_est) else: cc = stats.corrcoef(y[-20000:], y_est[-20000:]) ev = stats.variance_explained(y[-20000:], y_est[-20000:]) return fun, cc, ev
def fit(cell_num, model, objective, init_num, num_optims, options): ''' Fit one cell Inputs ------ cell_num (string) : cell number model (string) : type of model optimized objective (string): type of objective function optimized init_num (string) : initial parameter of model num_optims (int): Number of optimization repeated. One optimization is MAX_ITER iteration(step gradient). Total iteration would be Tot_Iter = MAX_ITER * num_optims This way, the optimization process can keep track of intermediate cost values, cross-validation(test values) values, and other intermediate statistics. For each optimization, results are saved options (dictionary) pathway (int) : number of pathways for LNK or LNKS model (1 or 2) crossval (bool): cross-validation 'True' or 'False' is_grad (bool): gradient On(True) or Off(False) Optimization ------------ Using the objective function fobj, model function f, and initial parameter theta_init, optimize the model and get results, using the method of the cell class. cellclass.py module is assumed to be available and in the PYTHONPATH optimizationtools.py is assumed to be available and in the PYTHONPATH cell.fit: (function, method) ''' # load cell data cell = ldt.loadcell(cell_num) # select type of model, objective, boundary function f = models[model] fobj = objectives[objective] bnds = bounds[model] bound = bnds(pathway=options['pathway']) # get initials theta_init = get_initial(model, init_num) # For the case of Spiking_est model(using LNK output as an input to Spiking model) # need to compute v_est in advance and put it in to the cell class. if model.lower() == 'spiking_est': theta_init_LNK = theta_init[0] crossval = options['crossval'] options['crossval'] = False data = ccls.get_data(cell, 'LNK', options) cell.v_est = lnks.LNK_f(theta_init_LNK, data[0], options['pathway']) options['crossval'] = crossval theta_init = theta_init[1] thetas = np.array(np.zeros([num_optims+1, theta_init.size])) thetas[0,:] = theta_init # compute initial objective value and correlation coefficient fun_train, cc_train, evar_train = compute_func_values(cell,theta_init,model,fobj, f,options, True) fun_test, cc_test, evar_test = compute_func_values(cell,theta_init,model, fobj,f, options, False) # Run Optimization # print("\nFit cell %s. Optimize %s model using %s objective function\n" %(cell_num, model, objective)) print("%15s %17s %17s %17s %17s %17s %17s" %("Process(%)","Update-Time(sec)","funs", "corrcoef(train)","var-expl(train)", "corrcoef(test)", "var-expl(test)")) print("%15.2f %17.2f %17.5f %17.5f %17.5f %17.5f %17.5f" %(0, 0, fun_train,cc_train,evar_train,cc_test,evar_test)) # save results to Data Frame # idxs = np.array(range(num_optims+1)) # cols = ["Optimization Process(%)","Update Time(sec)","funs","corrcoef(train)","var-expl(train)","corrcoef(test)","var-expl(test)"] # df = pd.DataFrame(index=idxs, columns=cols) # df.loc[0] = (0, 0, fun_train,cc_train,evar_train,cc_test,evar_test) # df_thetas = pd.DataFrame(index=idxs, columns=list(range(len(theta_init)))) # df_thetas.loc[0] = theta_init for i in range(1, num_optims+1): t0 = time.time() cell.fit(fobj, f, theta_init, model, bound, options) t1 = time.time() # train result theta, fun_train, cc_train, evar_train = get_results(cell) thetas[i,:] = theta # test result fun_test, cc_test, evar_test = compute_func_values(cell,theta,model,fobj,f,options,False) theta_init = theta print("%15.2f %17.2f %17.5f %17.5f %17.5f %17.5f %17.5f" %( (i/num_optims * 100),(t1-t0),fun_train,cc_train,evar_train,cc_test,evar_test)) # output = [(i/num_optims * 100),(t1-t0),fun_train,cc_train,evar_train,cc_test,evar_test] # df.loc[i] = output # df_thetas.loc[i] = theta print("\n") save_results(cell, cell_num, model, init_num, theta, fun_train, cc_train, evar_train,fun_test, cc_test, evar_test) if model.lower in ['Spiking','Spiking_est']: np.savetxt(cell_num+'_'+init_num[1]+'_theta.csv', thetas, delimiter=",") else: np.savetxt(cell_num+'_'+init_num[0]+'_theta.csv', thetas, delimiter=",") # df.to_csv(cell_num+'.csv', sep='\t') # df_thetas.to_csv(cell_num+'_thetas.csv', sep='\t') return cell