def FP_L2_vs_Sup(N_spikes = 1000, N_trains=20): N_phi = 20; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) batch_start = time.clock() base_name = 'sinusoidal_spike_train_N=%d_'%N_spikes D = DataHarvester('FPvsWFP_4x%d_N=%d'%(N_trains,N_spikes)) for regime_name, T_thresh in zip(['subT','superT', 'crit', 'superSin'], 4*[64.]): regime_label = base_name + regime_name for sample_id in xrange(1,N_trains +1): file_name = regime_label + '_' + str(sample_id) print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) D.setRegime(regime_name,abg_true, Tsim=-1.0) #### N_thresh = 10 binnedTrain.pruneBins(None, N_thresh = 10, T_thresh=T_thresh) D.addSample(sample_id, binnedTrain.getTf(), binnedTrain.getBinCount(), binnedTrain.getSpikeCount()) abg_init = initialize_right_2std(binnedTrain) abg_init[1] = amax([.1, abg_init[1]]) abg_init[2] = amax([.0, abg_init[2]]) D.addEstimate(sample_id, 'init_N10', abg_init,.0) binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) dx = .025; dt = FPMultiPhiSolver.calculate_dt(dx, abg_true, -1.0) theta = binnedTrain.theta binnedTrain.pruneBins(None, N_thresh = 1, T_thresh=T_thresh) phis = binnedTrain.bins.keys(); S = FPMultiPhiSolver(theta, phis, dx, dt, binnedTrain.getTf(), X_min = -1.0) start = time.clock() abg_est = FPL2Estimator(S,binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'FP_L2', abg_est, finish-start) start = time.clock() abg_est = FPSupEstimator(S,binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'FP_Sup', abg_est, finish-start) D.closeFile() print 'batch time = ', (time.clock() - batch_start) / 3600.0, ' hrs'
def ThetaEstimate(N_spikes = 1000, N_trains=100, N_phi=20, thetas = [1, 5, 10, 20]): print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) batch_start = time.clock() base_name = 'sinusoidal_spike_train_N=%d_critical_theta='%N_spikes T_thresh = 64. D = DataHarvester('ThetaEstimate_%dx%d_N=%d'%(len(thetas),N_trains,N_spikes)) for sample_id in xrange(1,N_trains +1): for theta in thetas: regime_name = 'theta%d'%theta regime_label = base_name + '%d'%theta file_name = regime_label + '_%d'%sample_id print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) D.setRegime(regime_name,abg_true, Tsim=-1.0) binnedTrain.pruneBins(None, N_thresh = 5, T_thresh=T_thresh) D.addSample(sample_id, binnedTrain.getTf(), binnedTrain.getBinCount(), binnedTrain.getSpikeCount()) abg_init = initialize_right_2std(binnedTrain) abg_init[1] = amax([.1, abg_init[1]]) abg_init[2] = amax([.0, abg_init[2]]) D.addEstimate(sample_id, 'Initializer', abg_init,.0, warnflag = 0) #RELOAD ALL DATA: binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) binnedTrain.pruneBins(None, N_thresh = 1, T_thresh=T_thresh) #Weighted Fortet: start = time.clock() abg_est, warnflag = FortetEstimatorSup(binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'Fortet', abg_est, finish-start, warnflag) #Weighted F-P: dx = .025; dt = FPMultiPhiSolver.calculate_dt(dx, abg_true, -1.0) phis = binnedTrain.bins.keys(); S = FPMultiPhiSolver(binnedTrain.theta, phis, dx, dt, binnedTrain.getTf(), X_min = -1.0) start = time.clock() abg_est, warnflag = FPSupEstimator(S, binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'FP', abg_est, finish-start, warnflag) D.closeFile() print 'batch time = ', (time.clock() - batch_start) / 3600.0, ' hrs'
def GradedDriver(): from scipy.optimize import fmin_bfgs N_phi = 10; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) print 'GradedEstimator' for file_name in ['sinusoidal_spike_train_T=20000_subT_3.path', 'sinusoidal_spike_train_T=20000_subT_8.path', 'sinusoidal_spike_train_T=20000_subT_13.path']: print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) binnedTrain.pruneBins(None, N_thresh = 32, T_thresh = 32.) abg_est = abs( initialize5(binnedTrain)) print 'abg_init = ',abg_est theta = binnedTrain.theta for T_thresh, N_thresh, max_iters in zip([32/8., 32/4., 32/2., 32.], [128, 128, 64, 32], [50,50,100,None]): binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) binnedTrain.pruneBins(None, N_thresh, T_thresh) print 'N_bins = ', len(binnedTrain.bins.keys()) Tf = binnedTrain.getTf() print 'Tf = ', Tf dx = .02; dt = FPMultiPhiSolver.calculate_dt(dx, 4., 10.) phis = binnedTrain.bins.keys(); S = FPMultiPhiSolver(theta, phis, dx, dt, Tf, X_MIN = -.5) from scipy.optimize import fmin def func(abg): 'Solve it:' Fs = S.solve(abg, visualize=False)[:,:,-1] Ss = S.transformSurvivorData(binnedTrain) Ls = Fs - Ss 'Return' G = .5*sum(Ls*Ls)*S._dt return G abg_est = fmin(func, abg_est, ftol = 1e-2*T_thresh, maxiter=max_iters) print 'current_estimate = ', abg_est print 'final estimate = ', abg_est
def CustomEstimate(spike_trains): D = DataPrinter('') for spike_train in spike_trains: regime_name = spike_train[0]; sample_id = spike_train[1] N_spikes = spike_train[2]; N_phi = spike_train[3]; phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) base_name = 'sinusoidal_spike_train_N=%d_'%N_spikes T_thresh = 128.0; regime_label = base_name + regime_name file_name = regime_label + '_' + str(sample_id) print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) D.setRegime(regime_name,abg_true, Tsim=-1.0) binnedTrain.pruneBins(None, N_thresh = 5, T_thresh=T_thresh) D.addSample(sample_id, binnedTrain.getTf(), binnedTrain.getBinCount(), binnedTrain.getSpikeCount()) abg_init = initialize_right_2std(binnedTrain) abg_init[1] = amax([.1, abg_init[1]]) abg_init[2] = amax([.0, abg_init[2]]) D.addEstimate(sample_id, 'Initializer', abg_init,.0, warnflag = 0) #RELOAD ALL DATA: binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) binnedTrain.pruneBins(None, N_thresh = 1, T_thresh=T_thresh) #Weighted Fortet: start = time.clock() abg_est, warnflag = FortetEstimatorSup(binnedTrain, abg_init, verbose = True) finish = time.clock() D.addEstimate(sample_id, 'Fortet', abg_est, finish-start, warnflag) #Weighted F-P: dx = .025; dt = FPMultiPhiSolver.calculate_dt(dx, abg_true, -1.0) phis = binnedTrain.bins.keys(); S = FPMultiPhiSolver(binnedTrain.theta, phis, dx, dt, binnedTrain.getTf(), X_min = -1.0) start = time.clock() abg_est, warnflag = FPSupEstimator(S, binnedTrain, abg_init, verbose = True) finish = time.clock() D.addEstimate(sample_id, 'FP', abg_est, finish-start, warnflag) del D
def TestEstimate(N_spikes = 100, N_trains=5, N_phi=8): print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) batch_start = time.clock() base_name = 'sinusoidal_spike_train_N=%d_'%N_spikes D = DataPrinter('') for regime_name, T_thresh in zip(['superT'], [64]): regime_label = base_name + regime_name for sample_id in xrange(1,N_trains +1): file_name = regime_label + '_' + str(sample_id) print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) D.setRegime(regime_name,abg_true, Tsim=-1.0) binnedTrain.pruneBins(None, N_thresh = 5, T_thresh=T_thresh) D.addSample(sample_id, binnedTrain.getTf(), binnedTrain.getBinCount(), binnedTrain.getSpikeCount()) abg_init = initialize_right_2std(binnedTrain) abg_init[1] = amax([.1, abg_init[1]]) abg_init[2] = amax([.0, abg_init[2]]) D.addEstimate(sample_id, 'Initializer', abg_init,.0, warnflag = 0) #RELOAD ALL DATA: binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) binnedTrain.pruneBins(None, N_thresh = 1, T_thresh=T_thresh) #Weighted Fortet: start = time.clock() abg_est, warnflag = FortetEstimatorSup(binnedTrain, abg_init, verbose = True) finish = time.clock() D.addEstimate(sample_id, 'Fortet', abg_est, finish-start, warnflag) #Weighted F-P: dx = .025; dt = FPMultiPhiSolver.calculate_dt(dx, abg_true, -1.0) phis = binnedTrain.bins.keys(); S = FPMultiPhiSolver(binnedTrain.theta, phis, dx, dt, binnedTrain.getTf(), X_min = -1.0) start = time.clock() abg_est, warnflag = FPSupEstimator(S, binnedTrain, abg_init, verbose = True) finish = time.clock() D.addEstimate(sample_id, 'FP', abg_est, finish-start, warnflag) del D print 'batch time = ', (time.clock() - batch_start) / 3600.0, ' hrs'
def ThetaBox(thetas, sample_id = 1): D = DataPrinter('') for theta in thetas: N_phi = 20; phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) file_name = 'sinusoidal_spike_train_N=1000_critical_theta=%d_%d'%(theta, sample_id) print file_name T_thresh = 128.0; binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) print 'ps = ', ps.getParams() regime_name = 'theta=%d'%int(ps._theta) print regime_name D.setRegime(regime_name,abg_true, Tsim=-1.0) binnedTrain.pruneBins(None, N_thresh = 5, T_thresh=T_thresh) D.addSample(sample_id, binnedTrain.getTf(), binnedTrain.getBinCount(), binnedTrain.getSpikeCount()) abg_init = initialize_right_2std(binnedTrain, cap_beta_gamma=True) D.addEstimate(sample_id, 'Initializer', abg_init,.0, warnflag = 0) #RELOAD ALL DATA: binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) binnedTrain.pruneBins(None, N_thresh = 1, T_thresh=T_thresh) #Weighted Fortet: start = time.clock() abg_est, warnflag = FortetEstimatorSup(binnedTrain, abg_init, verbose = False) finish = time.clock() D.addEstimate(sample_id, 'Fortet', abg_est, finish-start, warnflag) #Weighted F-P: dx = .025; dt = FPMultiPhiSolver.calculate_dt(dx, abg_true, -1.0) phis = binnedTrain.bins.keys(); S = FPMultiPhiSolver(binnedTrain.theta, phis, dx, dt, binnedTrain.getTf(), X_min = -1.0) start = time.clock() abg_est, warnflag = FPSupEstimator(S, binnedTrain, abg_init, verbose = False) finish = time.clock() D.addEstimate(sample_id, 'FP', abg_est, finish-start, warnflag) del D
def Fortet_SupVsL2(N_spikes = 1000, N_trains = 16): N_phi = 20; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) batch_start = time.clock() base_name = 'sinusoidal_spike_train_N=%d_'%N_spikes D = DataHarvester('Fortet_SupVsL2_4x%d'%N_trains) # for regime_name, T_thresh in zip(['subT', 'crit', 'superSin', 'superT'], # [64., 64, 32., 32.]): for regime_name, T_thresh in zip(['crit', 'superSin', 'superT'], [64, 32., 32.]): regime_label = base_name + regime_name for sample_id in xrange(1,N_trains+1): file_name = regime_label + '_' + str(sample_id) print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) D.setRegime(regime_name,abg_true, Tsim=-1.0) phi_omit = None binnedTrain.pruneBins(phi_omit, N_thresh = 10, T_thresh=T_thresh) D.addSample(sample_id, binnedTrain.getTf(), binnedTrain.getBinCount(), binnedTrain.getSpikeCount()) abg_init = initialize_right_2std(binnedTrain) binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) start = time.clock() abg_est = FortetEstimatorL2(binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'FortetL2', abg_est, finish-start) print abg_est, ' | %.2f'%(finish-start) start = time.clock() abg_est = FortetEstimatorSup(binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'FortetSup', abg_est, finish-start) print abg_est, ' | %.2f'%(finish-start) D.closeFile() print 'batch time = ', (time.clock() - batch_start) / 3600.0, ' hrs'
def BFGSGradedEstimator(): from scipy.optimize import fmin_bfgs print 'GradedEstimator' N_phi = 10; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) phi_omit = None for file_name in ['sinusoidal_spike_train_T=20000_subT_4.path', 'sinusoidal_spike_train_T=20000_subT_7.path', 'sinusoidal_spike_train_T=20000_subT_13.path']: print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) binnedTrain.pruneBins(phi_omit, N_thresh = 32, T_thresh = 32.) abg_est = abs( initialize5(binnedTrain)) print 'abg_init = ',abg_est for T_thresh, N_thresh, max_iters in zip([32/8., 32/4., 32/2., 32.], [128, 128, 64, 32], [32,24,16,8]): binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phis) binnedTrain.pruneBins(phi_omit, N_thresh, T_thresh) Tf = binnedTrain.getTf() print 'Tf = ', Tf print 'N_bins = ', len(binnedTrain.bins.keys()) solver_phis = binnedTrain.bins.keys(); theta = binnedTrain.theta x_min = -.5; S = FPMultiPhiSolver(theta, solver_phis, .1, .1, Tf, X_MIN = x_min) lE = Estimator(S, binnedTrain, verbose = True) # abg_est = fmin_bfgs(lE.func, abg_init, lE.dfunc, gtol = 1e-6*binnedTrain.getTf(), maxiter= 128, full_output = 0) abg_est, fopt, gopt, Bopt, func_calls, grad_calls, warnflag = fmin_bfgs(lE.func, abg_est, lE.dfunc, gtol = 1e-08*binnedTrain.getTf(), maxiter=max_iters, full_output = 1) print 'estimate gradient =', gopt print 'current_estimate = ', abg_est print 'final estimate = ', abg_est
def InitTauSamples(): N_phi = 20; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) base_name = 'sinusoidal_spike_train_N=1000_' for regime_name, T_thresh in zip(['superT', 'subT', 'crit', 'superSin'], [4., 32, 16., 16.]): regime_label = base_name + regime_name sample_id = randint(1,17) file_name = regime_label + '_' + str(sample_id) print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) print abg_true phi_omit = None binnedTrain.pruneBins(phi_omit, N_thresh = 64, T_thresh=T_thresh) Tf = binnedTrain.getTf() abgt_init = initialize2_tau(binnedTrain) print '%.2g,%.2g,%.2g,%.2g' %(abgt_init[0], abgt_init[1],abgt_init[2],abgt_init[3]) abgt_init = initialize5_tau(binnedTrain) print '%.2g,%.2g,%.2g,%.2g' %(abgt_init[0], abgt_init[1],abgt_init[2],abgt_init[3]) print " "
def GradedNMEstimator(file_name, phi_norms, abg_est, T_max, N_thresh_final): for T_thresh, N_thresh, max_iters in zip(array([1./8., 1./4., 1./2., 1.])*T_max, array([2,2,2,1])*N_thresh_final, [50,50,100,None]): binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) binnedTrain.pruneBins(None, N_thresh, T_thresh) print 'N_bins = ', len(binnedTrain.bins.keys()) Tf = binnedTrain.getTf() print 'Tf = ', Tf dx = .02; dt = FPMultiPhiSolver.calculate_dt(dx, 5., 10.) phis = binnedTrain.bins.keys(); theta = binnedTrain.theta S = FPMultiPhiSolver(theta, phis, dx, dt, Tf, X_MIN = -.5) from scipy.optimize import fmin def func(abg): 'Solve it:' Fs = S.solve(abg, visualize=False)[:,:,-1] Ss = S.transformSurvivorData(binnedTrain) Ls = Fs - Ss 'Return' G = .5*sum(Ls*Ls)*S._dt return G abg_est = fmin(func, abg_est, ftol = 1e-2*T_thresh, maxiter=max_iters) print 'current_estimate = ', abg_est return abg_est
def calculateInitSDFs(): N_phi = 16; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) for regime_idx, regime_name in enumerate(['superT', 'superSin', 'crit','subT']): # for regime_name in ['superT']: filename = RESULTS_DIR + '/Fs_%s.npz'%regime_name npzfile = load(filename) ts = npzfile['ts'] phis = npzfile['phis'] regime_label = 'sinusoidal_spike_train_N=1000_' + regime_name + '_12' binnedTrain = BinnedSpikeTrain.initFromFile(regime_label, phi_norms) binnedTrain.pruneBins(None, N_thresh = 16, T_thresh=128.) ps = binnedTrain._Train._params abg = initialize_right_2std(binnedTrain) # abg = array((ps._alpha, ps._beta, ps._gamma)) GsInit = calcG_U_Const(abg,ts,phis); filename= RESULTS_DIR + '/Gs_%s'%regime_name print 'saving Gs to ', filename savez(filename, GsInit=GsInit);
def writeWithHarvester(): from BinnedSpikeTrain import BinnedSpikeTrain from InitBox import initialize5 from Simulator import Path, OUSinusoidalParams import time N_phi = 20; print 'N_phi = ', N_phi phis = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) # D = DataHarvester('test2') D = DataHarvester('test2', 'test3') base_name = 'sinusoidal_spike_train_T=' for regime_name, T_sim, T_thresh in zip(['superT', 'subT', 'crit', 'superSin'], [5000 , 20000, 5000, 5000], [4., 32, 16., 16.]): regime_label = base_name + str(T_sim)+ '_' + regime_name for sample_id in xrange(3,4): file_name = regime_label + '_' + str(sample_id) + '.path' print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phis) ps = binnedTrain._Path._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) D.setRegime(regime_name,abg_true, T_sim) phi_omit = None binnedTrain.pruneBins(phi_omit, N_thresh = 64, T_thresh=T_thresh) Tf = binnedTrain.getTf() D.addSample(sample_id, Tf, binnedTrain.getBinCount(), binnedTrain.getSpikeCount()) start = time.clock() abg_init = initialize5(binnedTrain) finish = time.clock() D.addEstimate(sample_id, 'Initializer', abg_init, finish-start) abg_est = abg_init start = time.clock() # abg_est = NMEstimator(S, binnedTrain, abg_init) time.sleep(rand()) finish = time.clock() D.addEstimate(sample_id, 'Nelder-Mead', abg_est, finish-start) start = time.clock() # abg_est = BFGSEstimator(S, binnedTrain, abg_init) time.sleep(rand()) finish = time.clock() D.addEstimate(sample_id, 'BFGS', abg_est, finish-start) start = time.clock() # abg_est = FortetEstimator(binnedTrain, abg_init) time.sleep(rand()) finish = time.clock() D.addEstimate(sample_id, 'Fortet', abg_est, finish-start)
def CvsPyEstimate(): N_phi = 20; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) batch_start = time.clock() base_name = 'sinusoidal_spike_train_N=1000_' D = DataHarvester('CvsPY_2x4') for regime_name, T_thresh in zip(['subT', 'superSin'], [32, 16.]): regime_label = base_name + regime_name for sample_id in xrange(1,4): file_name = regime_label + '_' + str(sample_id) print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) D.setRegime(regime_name,abg_true, Tsim=-1.0) phi_omit = None binnedTrain.pruneBins(phi_omit, N_thresh = 64, T_thresh=T_thresh) Tf = binnedTrain.getTf() D.addSample(sample_id, Tf, binnedTrain.getBinCount(), binnedTrain.getSpikeCount()) start = time.clock() abg_init = initialize_right_2std(binnedTrain) finish = time.clock() D.addEstimate(sample_id, 'Initializer', abg_init, finish-start) dx = .025; dt = FPMultiPhiSolver.calculate_dt(dx, abg_true, -1.0) phis = binnedTrain.bins.keys(); theta = binnedTrain.theta S = FPMultiPhiSolver(theta, phis, dx, dt, Tf, X_min = -1.0) start = time.clock() abg_est = cNMEstimator(S, binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'FP-C', abg_est, finish-start) start = time.clock() abg_est = NMEstimator(S, binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'FP-PY', abg_est, finish-start) D.closeFile()
def FortetVsWeightedFortet(): N_phi = 20; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) batch_start = time.clock() base_name = 'sinusoidal_spike_train_N=1000_' D = DataHarvester('FvsWF_4x16') for regime_name, T_thresh in zip(['superT', 'subT', 'crit', 'superSin'], [6., 64, 32., 32.]): regime_label = base_name + regime_name for sample_id in xrange(1,17): file_name = regime_label + '_' + str(sample_id) print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) D.setRegime(regime_name,abg_true, Tsim=-1.0) phi_omit = None binnedTrain.pruneBins(phi_omit, N_thresh = 10, T_thresh=T_thresh) Tf = binnedTrain.getTf() D.addSample(sample_id, Tf, binnedTrain.getBinCount(), binnedTrain.getSpikeCount()) start = time.clock() abg_init = initialize_right_2std(binnedTrain) finish = time.clock() D.addEstimate(sample_id, 'Initializer', abg_init, finish-start) start = time.clock() abg_est = FortetEstimator(binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'Fortet10', abg_est, finish-start) start = time.clock() abg_est = WeightedFortetEstimator(binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'WeghtedFortet', abg_est, finish-start) binnedTrain.pruneBins(phi_omit, N_thresh = 64, T_thresh=T_thresh) start = time.clock() abg_est = FortetEstimator(binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'Fortet64', abg_est, finish-start) D.closeFile() print 'batch time = ', (time.clock() - batch_start) / 3600.0, ' hrs'
def NelderMeadSubTEstimator(): N_phi = 20; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) batch_start = time.clock() base_name = 'sinusoidal_spike_train_T=' D = DataHarvester('SubT_NMx16_refined_sim_dt') for regime_name, T_sim, T_thresh in zip(['subT'], [20000], [32.]): regime_label = base_name + str(T_sim)+ '_' + regime_name for sample_id in xrange(1,17): file_name = regime_label + '_' + str(sample_id) + '.path' print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) D.setRegime(regime_name,abg_true, T_sim) phi_omit = None binnedTrain.pruneBins(phi_omit, N_thresh = 64, T_thresh=T_thresh) Tf = binnedTrain.getTf() D.addSample(sample_id, Tf, binnedTrain.getBinCount(), binnedTrain.getSpikeCount()) dx = .04; dt = FPMultiPhiSolver.calculate_dt(dx, 4., 2.) phis = binnedTrain.bins.keys(); theta = binnedTrain.theta S = FPMultiPhiSolver(theta, phis, dx, dt, Tf, X_MIN = -.5) start = time.clock() abg_init = initialize5(binnedTrain) finish = time.clock() D.addEstimate(sample_id, 'Initializer', abg_init, finish-start) abg_init = abs(abg_init) start = time.clock() abg_est = NMEstimator(S, binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'Nelder-Mead', abg_est, finish-start) D.closeFile() print 'batch time = ', (time.clock() - batch_start) / 3600.0, ' hrs'
def MixedDriver(): N_phi = 20; print 'N_phi = ', N_phi phis = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) # file_name = 'sinusoidal_spike_train_N=1000_superT_13' file_name = 'sinusoidal_spike_train_N=1000_subT_1' # file_name = 'sinusoidal_spike_train_N=1000_crit_5' # intervalStats(file_name) binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phis) phi_omit = None # phi_omit = r_[(linspace(.15, .45, 4), # linspace(.55,.95, 5) )] *2*pi/ binnedTrain.theta binnedTrain.pruneBins(phi_omit, N_thresh = 80, T_thresh= 16.) print 'N_bins = ', len(binnedTrain.bins.keys()) Tf = binnedTrain.getTf() #/ 2. print 'Tf = ', Tf params = binnedTrain._Train._params abg_true = (params._alpha, params._beta, params._gamma) print 'true = ', abg_true abg_init = initialize_right_2std(binnedTrain) print 'init = ', abg_init start = time.clock() abg_est = MixedEstimator(abg_init, binnedTrain) finish = time.clock() print 'Mixed est = ', abg_est mixed_time = finish-start print 'Mixed time = ', mixed_time from AdjointEstimator import FortetEstimator start = time.clock() abg_est = FortetEstimator(binnedTrain, abg_est) finish = time.clock() print 'Mixed+Fortet est = ', abg_est print 'MIxed+Fortet time = ', finish-start + mixed_time #Compare with straight up Fortet: start = time.clock() abg_est = FortetEstimator(binnedTrain, abg_init) finish = time.clock() print 'Fortet est = ', abg_est print 'Fortet time = ', finish-start
def estimateTau(regime = 'crit', number=11, N_thresh = 64, T_thresh = 16. ): file_name = 'sinusoidal_spike_train_N=1000_' + regime + '_' + str(number) print file_name N_phi = 20; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) binnedTrain.pruneBins(None, N_thresh, T_thresh) print 'N_bins = ', len(binnedTrain.bins.keys()) Tf = binnedTrain.getTf() print 'Tf = ', Tf abg_init = initialize_right_2std(binnedTrain) phis = binnedTrain.bins.keys(); theta = binnedTrain.theta dx = .02; dt = FPMultiPhiSolver.calculate_dt(dx, abg_init,x_min= -1.0) S = FPMultiPhiSolver(theta, phis, dx, dt, Tf, X_min = -2.) abgt_init = [abg_init[0], abg_init[1], abg_init[2], .5] print 'abgt_init = ', abgt_init start = time.clock() abgt_est = TaucharEstimator(S, binnedTrain, abgt_init) finish = time.clock() print 'abgt_est = ', abgt_est print 'compute time = ', finish-start print 'No tau comparison:' start = time.clock() abg_est = NMEstimator(S, binnedTrain, abg_init) finish = time.clock() print 'abg_est = ', abg_est print 'compute time = ', finish-start return abgt_est
def estimateSubT(N_spikes=100, sample_id =4, T_thresh = 32.): N_phi = 20; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) base_name = 'sinusoidal_spike_train_N=%d_'%N_spikes regime_name = 'subT' regime_label = base_name + regime_name file_name = regime_label + '_' + str(sample_id) print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Train._params print array((ps._alpha, ps._beta, ps._gamma)) #### N_thresh = 10 binnedTrain.pruneBins(None, N_thresh = 10, T_thresh=T_thresh) abg_init = initialize_right_2std(binnedTrain) print abg_init abg_init[1] = amax([.1, abg_init[1]]) abg_init[2] = amax([.0, abg_init[2]]) dx = .025; dt = FPMultiPhiSolver.calculate_dt(dx, abg_init, -1.0) print dx, dt theta = binnedTrain.theta ##### N_thresh = 1 binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) binnedTrain.pruneBins(None, N_thresh = 1, T_thresh=T_thresh) phis = binnedTrain.bins.keys(); S = FPMultiPhiSolver(theta, phis, dx, dt, binnedTrain.getTf(), X_min = -1.0) abg_est = WeightedFPEstimator(S,binnedTrain, abg_init) print abg_est
def BatchGradedNMEstimator(): N_phi = 20; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) batch_start = time.clock() base_name = 'sinusoidal_spike_train_T=' D = DataHarvester('GradedNMx16', 'GradedNM_SubTx16') N_thresh = 32 for regime_name, T_sim, T_thresh in zip(['subT'], [20000], [32.]): regime_label = base_name + str(T_sim)+ '_' + regime_name for sample_id in xrange(4,17): file_name = regime_label + '_' + str(sample_id) + '.path' print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Path._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) D.setRegime(regime_name,abg_true, T_sim) phi_omit = None binnedTrain.pruneBins(phi_omit, N_thresh = N_thresh, T_thresh=T_thresh) Tf = binnedTrain.getTf() D.addSample(sample_id, Tf, binnedTrain.getBinCount(), binnedTrain.getSpikeCount()) start = time.clock() abg_init = initialize5(binnedTrain) finish = time.clock() D.addEstimate(sample_id, 'Initializer', abg_init, finish-start) start = time.clock() abg_est = GradedNMEstimator(file_name, phi_norms, abg_init, T_thresh, N_thresh) finish = time.clock() D.addEstimate(sample_id, 'Graded_Nelder-Mead', abg_est, finish-start) start = time.clock() abg_est = FortetEstimator(binnedTrain, abg_init) finish = time.clock() D.addEstimate(sample_id, 'Fortet', abg_est, finish-start) D.closeFile() print 'batch time = ', (time.clock() - batch_start) / 3600.0, ' hrs'
def MultiTrainEstimator(): phis = linspace(.05, .95, 10) for file_name in ['sinusoidal_spike_train_T=1000.path', 'sinusoidal_spike_train_T=6000.path', 'sinusoidal_spike_train_T=10000_superSin.path', 'sinusoidal_spike_train_T=10000_crit.path']: print '#'*64 print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phis) phi_omit = None binnedTrain.pruneBins(phi_omit, N_thresh = 64, T_thresh = 10.) print 'N_bins = ', len(binnedTrain.bins.keys()) Tf = binnedTrain.getTf() print 'Tf = ', Tf dx = .05; dt = FPMultiPhiSolver.calculate_dt(dx, 5., 2.) binphis = binnedTrain.bins.keys(); theta = binnedTrain.theta S = FPMultiPhiSolver(theta, binphis, dx, dt, Tf) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) print 'abg_true = ', abg_true abg_init = abs(abg_true + abg_true * randn(3)) ; print 'abg_init = ', abg_init start = time.clock() abg_est = TNCEstimator(S, binnedTrain, abg_init) print 'Est. time = ', time.clock() - start print 'abg_est = ', abg_est print 'error = ', abg_true - abg_est start = time.clock() abg_est = NMEstimator(S, binnedTrain, abg_init) print 'Est. time = ', time.clock() - start print 'abg_est = ', abg_est print 'error = ', abg_true - abg_est
def CLossFHarness(): errors = [] for N_spikes, N_phi in zip( [100,1000], [8,20]): phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) base_name = 'sinusoidal_spike_train_N=%d_'%N_spikes for regime in ['superT', 'crit', 'subT','superSin']: regime_label = base_name + regime # for sample_id in [1,23, 36, 77, 99]: for sample_id in [43]: file_name = regime_label + '_' + str(sample_id) print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) bins = binnedTrain.bins; phis = bins.keys() N_phi = len(phis) def closs_function(abg): error = .0; for (phi_m, phi_idx) in zip(phis, xrange(N_phi)): Is = bins[phi_m]['Is'] N_Is = len(Is); Tf = amax(Is); ts = linspace(1e-8, Tf+1e-2, 500) #Call C to compute the lhs - rhs abgthphi = r_[abg, theta, phi_m] difference = ext_fpc.FortetError(abgthphi, ts, Is) raw_error = amax(difference); weighted_error = N_Is * raw_error; error += weighted_error return error alpha, beta, gamma, theta = binnedTrain._Train._params.getParams() start = time.clock() c_error = closs_function([alpha, beta, gamma]) print 'ctime = ', time.clock() - start
def VisualizeSinusoidallyDominating(): N_phi = 20; print 'N_phi = ', N_phi phis = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) phi_omit = None file_name = 'sinusoidal_spike_train_T=5000_superSin_11.path' binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phis) binnedTrain.pruneBins(phi_omit, N_thresh = 64, T_thresh=16.) print 'N_bins = ', len(binnedTrain.bins.keys()) Tf = binnedTrain.getTf() print 'Tf = ', Tf solver_phis = binnedTrain.bins.keys(); theta = binnedTrain.theta; ps = binnedTrain._Path._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) abg = abg_true visualizeData_vs_Fortet(abg, binnedTrain, theta, title_tag = 'TRUE: ', save_fig_name='SuperSin_true_params') get_current_fig_manager().window.showMaximized() abg_est = [.494,.140,1.11] abg = abg_est visualizeData_vs_Fortet(abg, binnedTrain, theta, title_tag = 'F-P: ', save_fig_name='SuperSin_NM_est') get_current_fig_manager().window.showMaximized() abg_est = [.541,.181, .983] abg = abg_est visualizeData_vs_Fortet(abg, binnedTrain,theta, title_tag = 'Fortet: ', save_fig_name='SuperSin_Fortet_est') get_current_fig_manager().window.showMaximized()
def BatchInit5_vs_InitRightstd(): N_phi = 20; print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) batch_start = time.clock() base_name = 'sinusoidal_spike_train_N=1000_' D = DataHarvester('InitComparison4x100_N100') for regime_name, T_thresh in zip(['superT', 'subT', 'crit', 'superSin'], [4., 32, 16., 16.]): regime_label = base_name + regime_name for sample_id in xrange(1,17): file_name = regime_label + '_' + str(sample_id) print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) D.setRegime(regime_name,abg_true, -.1) phi_omit = None binnedTrain.pruneBins(phi_omit, N_thresh = 64, T_thresh=T_thresh) Tf = binnedTrain.getTf() D.addSample(sample_id, Tf, binnedTrain.getBinCount(), binnedTrain.getSpikeCount()) start = time.clock() abg_init = initialize5(binnedTrain) finish = time.clock() D.addEstimate(sample_id, 'Init5pts', abg_init, finish-start) start = time.clock() abg_init = initialize_right_2std(binnedTrain) finish = time.clock() D.addEstimate(sample_id, 'Init_right_2std', abg_init, finish-start) D.closeFile() print 'batch time = ', (time.clock() - batch_start) / 60.0, ' mins'
def calculateExactSDFs(): N_phi = 4; print 'N_phi = ', N_phi phis = 2*pi*array([0,.25, .5, .75]) for regime_idx, regime_name in enumerate(['superT', 'superSin', 'crit','subT']): # for regime_name in ['superT']: regime_label = 'sinusoidal_spike_train_N=1000_' + regime_name + '_12' binnedTrain = BinnedSpikeTrain.initFromFile(regime_label, phis) Tf = binnedTrain.getTf() print 'Tf = ', Tf theta = binnedTrain.theta; print 'theta = ', theta ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) abg = abg_true xmin = FPMultiPhiSolver.calculate_xmin(Tf, abg, theta) # dx = .0125# dx = .0125; ; dx = .0125; dt = FPMultiPhiSolver.calculate_dt(dx, abg, xmin, factor = 5.) print 'xmin = ', xmin, ', dx, dt = ', dx, dt S = FPMultiPhiSolver(theta, phis, dx, dt, Tf, xmin) S.setTf(Tf) Fs = S.c_solve(abg) ts = S._ts; filename= RESULTS_DIR + '/Fs_%s'%regime_name print 'saving Fs to ', filename savez(filename, ts=ts, Gs=squeeze(Fs[:,:,-1]), phis=phis, Tf = Tf);
def postVisualizer(): N_phi = 20 print 'N_phi = ', N_phi phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) theta = 20 base_name = 'sinusoidal_spike_train_N=1000_critical_theta=%d'%theta T_thresh = 64. analyzer = DataAnalyzer('ThetaEstimate_4x100_N=1000') sample_id = 32 regime_label = base_name + '%d'%theta file_name = base_name + '_%d'%sample_id print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) binnedTrain.pruneBins(None, N_thresh = 1, T_thresh=T_thresh) regime_name = 'theta%d'%theta abg_true = analyzer.getTrueParamValues(regime_name); print abg_true abg_fortet = analyzer.getEstimates(sample_id, regime_name, 'Fortet')[0] print abg_fortet visualizeData_vs_Fortet(abg_fortet, binnedTrain, theta,title_tag = 'Fortet: estimates', save_fig_name='theta20_Fortet_estimates') visualizeData_vs_Fortet(abg_true, binnedTrain, theta,title_tag = 'Fortet: true', save_fig_name='theta20_Fortet_true') abg_fp = analyzer.getEstimates(sample_id, regime_name, 'FP')[0] print abg_fp dx = .025; dt = FPMultiPhiSolver.calculate_dt(dx, abg_true, -1.0) phis = binnedTrain.bins.keys(); S = FPMultiPhiSolver(binnedTrain.theta, phis, dx, dt, binnedTrain.getTf(), X_min = -1.0) visualizeData_vs_FP(S, abg_fp, binnedTrain,title_tag = 'FP: estimates', save_fig_name='theta20_FP_estimates') visualizeData_vs_FP(S, abg_true, binnedTrain,title_tag = 'FP: true', save_fig_name='theta20_FP_true')
def BFGSEstimator(): from scipy.optimize import fmin_bfgs phis = linspace(.05, .95, 10) phi_omit = None file_name = 'sinusoidal_spike_train_T=20000_subT_13.path' binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phis) binnedTrain.pruneBins(phi_omit, N_thresh = 64, T_thresh = 32.) print 'N_bins = ', len(binnedTrain.bins.keys()) Tf = binnedTrain.getTf() print 'Tf = ', Tf solver_phis = binnedTrain.bins.keys(); theta = binnedTrain.theta x_min = -.5; S = FPMultiPhiSolver(theta, solver_phis, .1, .1, Tf, X_MIN = x_min) ps = binnedTrain._Path._params abg_true = array([ps._alpha, ps._beta, ps._gamma]); print 'true = ', abg_true # abg_init = abg_true + .5*abg_true*randn(3); abg_init = [ 0.37345572 , 0.32178958 , 0.31556914] abg_init = [ 0.37366108 , 0.32516912, 0.31569902] print 'init = ', abg_init lE = Estimator(S, binnedTrain) # abg_est = fmin_bfgs(lE.func, abg_init, lE.dfunc, gtol = 1e-6*binnedTrain.getTf(), maxiter= 128, full_output = 0) abg_est, fopt, gopt, Bopt, func_calls, grad_calls, warnflag = fmin_bfgs(lE.func, abg_init, lE.dfunc, gtol = 1e-5*binnedTrain.getTf(), maxiter=32, full_output = 1) return abg_est
def NMSuperSinEstimator(): phis = linspace(.05, .95, 40) file_name = 'sinusoidal_spike_train_T=10000_superSin.path' print '#'*64 print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phis) phi_omit = None binnedTrain.pruneBins(phi_omit, N_thresh = 128, T_thresh = 8.) print 'N_bins = ', len(binnedTrain.bins.keys()) Tf = binnedTrain.getTf() print 'Tf = ', Tf dx = .025; dt = FPMultiPhiSolver.calculate_dt(dx, 5., 2.) binphis = binnedTrain.bins.keys(); theta = binnedTrain.theta S = FPMultiPhiSolver(theta, binphis, dx, dt, Tf) ps = binnedTrain._Train._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) print 'abg_true = ', abg_true abg_init = [0.716 , 0.199 , 0.51] print 'abg_init = ', abg_init start = time.clock() abg_est = NMEstimator(S, binnedTrain, abg_init) print 'Est. time = ', time.clock() - start print 'abg_est = ', abg_est print 'error = ', abg_true - abg_est
def Harness(sample_id=13, regime_name='superSin', N_spikes = 1000, visualize=False): from scipy.stats.distributions import norm N_phi = 20; phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) base_name = 'sinusoidal_spike_train_N=%d_'%N_spikes regime_label = base_name + regime_name # T_thresh = 128.; file_name = regime_label + '_' + str(sample_id) print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) # print 'Warning: pruning bins' # binnedTrain.pruneBins(None, N_thresh = 100) bins = binnedTrain.bins; phis = bins.keys() N_phi = len(phis) alpha, beta, gamma, theta = binnedTrain._Train._params.getParams() def loss_function_simple(abg, visualize, fig_tag = ''): error = .0; if visualize: figure() for (phi_m, phi_idx) in zip(phis, xrange(N_phi)): Is = bins[phi_m]['Is'] uniqueIs = bins[phi_m]['unique_Is'] a,b,g = abg[0], abg[1], abg[2] movingThreshold = getMovingThreshold(a,g, phi_m,binnedTrain.theta) LHS_numerator = movingThreshold(uniqueIs[1:]) *sqrt(2.) LHS_denominator = b * sqrt(1 - exp(-2*uniqueIs[1:])) LHS = 1 - norm.cdf(LHS_numerator / LHS_denominator) RHS = zeros_like(LHS) N = len(Is) for rhs_idx in xrange(1,len(uniqueIs)): t = uniqueIs[rhs_idx] lIs = Is[Is<t] taus = t - lIs; numerator = (movingThreshold(t) - movingThreshold(lIs)* exp(-taus)) * sqrt(2.) denominator = b * sqrt(1. - exp(-2*taus)) RHS[rhs_idx-1] = sum(1. - norm.cdf(numerator/denominator)) / N weight = len(Is) lerror = dot((LHS - RHS)**2 , diff(uniqueIs)) * weight; error += lerror if visualize: subplot(ceil(len(phis)/2),2, phi_idx+1);hold(True) ts = uniqueIs[1:]; plot(ts, LHS, 'b'); plot(ts, RHS, 'rx'); # annotate('$\phi$ = %.2g'%(phi_m), ((min(ts), max(LHS)/2.)), ) annotate('lerror = %.3g'%lerror,((min(ts), max(LHS)/2.)), ) if visualize: subplot(ceil(len(phis)/2),2, 1); title(fig_tag) return error def loss_function_nonvectorized(abg, visualize=False): error = .0; if visualize: figure(); for (phi_m, phi_idx) in zip(phis, xrange(N_phi)): # for phi_m in phis: Is = bins[phi_m]['Is'] N = len(Is); Tf = amax(Is); a,b,g = abg[0], abg[1], abg[2] movingThreshold = getMovingThreshold(a,g, phi_m) def LHS(ts): LHS_numerator = movingThreshold(ts) *sqrt(2.) LHS_denominator = b * sqrt(1 - exp(-2*ts)) return 1 - norm.cdf(LHS_numerator / LHS_denominator); # def RHS(t): # lIs = Is[Is<t]; # taus = t - lIs; # numerator = (movingThreshold(t) - movingThreshold(lIs)* exp(-taus)) * sqrt(2.) # denominator = b * sqrt(1. - exp(-2*taus)) # return sum(1. - norm.cdf(numerator/denominator)) / N def RHS(ts): if False == iterable(ts): ts = [ts] rhs = empty_like(ts) for t, t_indx in zip(ts, xrange(size(ts))): lIs = Is[Is<t]; taus = t - lIs; numerator = (movingThreshold(t) - movingThreshold(lIs)* exp(-taus)) * sqrt(2.) denominator = b * sqrt(1. - exp(-2*taus)) rhs[t_indx] = sum(1. - norm.cdf(numerator/denominator)) / N return rhs integrand = lambda t: (LHS(t) - RHS(t)) **2 from scipy.integrate import quad, quadrature, fixed_quad # quadrature, quad_error = quad(integrand, a= 1e-8, b=Tf+1e-8, limit = 50) quadrature, quad_error = quadrature(integrand, a= 1e-8, b=Tf+1e-8, tol=5e-03, rtol=1.49e-04, maxiter = 64, vec_func = True) # val , err_msg = fixed_quad( integrand, a= 1e-8, b=Tf+1e-8, # n = 12) # print 'quadrature = ',quadrature # print 'val = ',val # print 'difference = ', quadrature - val weight = len(Is) #VISUALIZE FOR NOW: if visualize: subplot(ceil(len(phis)/2),2, phi_idx+1);hold(True) ts = linspace(1e-8, Tf+1e-8, 100) ; lhs = empty_like(ts); rhs = empty_like(ts); for t, t_indx in zip(ts, xrange(len(ts))): lhs[t_indx] = LHS(t); rhs[t_indx] = RHS(t); plot(ts, lhs, 'b'); plot(ts, rhs, 'rx'); error += quadrature* weight; return error def loss_function_quadGaussian(abg, visualize=False, fig_tag = ''): error = .0; if visualize: figure(); for (phi_m, phi_idx) in zip(phis, xrange(N_phi)): # for phi_m in phis: Is = bins[phi_m]['Is'] unique_Is = bins[phi_m]['unique_Is'] N_Is = len(Is); Tf = amax(Is); a,b,g = abg[0], abg[1], abg[2] movingThreshold = getMovingThreshold(a,g, phi_m) def LHS(ts): LHS_numerator = movingThreshold(ts) *sqrt(2.) LHS_denominator = b * sqrt(1 - exp(-2*ts)) return 1 - norm.cdf(LHS_numerator / LHS_denominator); def RHS(ts): if False == iterable(ts): ts = array([ts]) # rhs = empty_like(ts) # Is.reshape((len(Is),1)) lIs = tile(Is, len(ts) ).reshape((len(ts), len(Is))).transpose() lts = tile(ts, (len(Is),1 ) ) mask = lIs < lts taus = (lts - lIs); #*mask #NOTE BELOW WE use abs(taus) since for non-positive taus we will mask away anyway: numerator = (movingThreshold(lts) - movingThreshold(lIs)* exp(-abs(taus))) * sqrt(2.) denominator = b * sqrt(1. - exp(-2*abs(taus))) rhs = sum( (1. - norm.cdf(numerator/denominator))*mask, axis=0) / N_Is return rhs integrand = lambda t: (LHS(t) - RHS(t)) **2 from scipy.integrate import quad, quadrature, fixed_quad # valcheck, quad_error = quad(integrand, a= 1e-8, b=Tf+1e-8, limit = 64) val, quad_error = quadrature(integrand, a= 1e-8, b=Tf+1e-8, tol=5e-03, rtol=1.49e-04, maxiter = 64, vec_func = True) weight = len(Is) lerror = val* weight; error += lerror if visualize: subplot(ceil(len(phis)/2),2, phi_idx+1); hold(True) # ts = linspace(1e-8, Tf+1e-8, 100) ; ts = unique_Is[1:]; lhs = LHS(ts); rhs = RHS(ts); plot(ts, lhs, 'b'); plot(ts, rhs, 'rx'); annotate('lerror = %.3g'%lerror,((min(ts), max(lhs)/2.)), ) if visualize: subplot(ceil(len(phis)/2),2,1); title(fig_tag) return error def loss_function_L1(abg, visualize=False, fig_tag = ''): error = .0; if visualize: figure(); for (phi_m, phi_idx) in zip(phis, xrange(N_phi)): # for phi_m in phis: Is = bins[phi_m]['Is'] unique_Is = bins[phi_m]['unique_Is'] N_Is = len(Is); Tf = amax(Is); a,b,g = abg[0], abg[1], abg[2] movingThreshold = getMovingThreshold(a,g, phi_m, theta) def LHS(ts): LHS_numerator = movingThreshold(ts) *sqrt(2.) LHS_denominator = b * sqrt(1 - exp(-2*ts)) return 1 - norm.cdf(LHS_numerator / LHS_denominator); def RHS(ts): if False == iterable(ts): ts = array([ts]) # rhs = empty_like(ts) # Is.reshape((len(Is),1)) lIs = tile(Is, len(ts) ).reshape((len(ts), len(Is))).transpose() lts = tile(ts, (len(Is),1 ) ) mask = lIs < lts taus = (lts - lIs); #*mask #NOTE BELOW WE use abs(taus) since for non-positive taus we will mask away anyway: numerator = (movingThreshold(lts) - movingThreshold(lIs)* exp(-abs(taus))) * sqrt(2.) denominator = b * sqrt(1. - exp(-2*abs(taus))) rhs = sum( (1. - norm.cdf(numerator/denominator))*mask, axis=0) / N_Is return rhs integrand = lambda t: abs(LHS(t) - RHS(t)) from scipy.integrate import quad, quadrature, fixed_quad print unique_Is val, quad_error = quad(integrand, a= 1e-8, b=Tf+1., limit = 64, points = sort(unique_Is) ) # val, quad_error = quadrature(integrand, a= 1e-8, b=Tf+1e-8, # tol=5e-03, rtol=1.49e-04, # maxiter = 64, # vec_func = True) # val , err_msg = fixed_quad( integrand, a= 1e-8, b=Tf+1e-8, weight = len(Is) lerror = val* weight; error += lerror if visualize: subplot(ceil(len(phis)/2),2, phi_idx+1); hold(True) # ts = linspace(1e-8, Tf+1e-8, 100) ; ts = unique_Is[1:]; lhs = LHS(ts); rhs = RHS(ts); plot(ts, lhs, 'b'); plot(ts, rhs, 'rx'); annotate('lerror = %.3g'%lerror,((min(ts), max(lhs)/2.)), ) if visualize: subplot(ceil(len(phis)/2),2,1); title(fig_tag) return error def loss_function_manualquad(abg, visualize=False, fig_tag = ''): error = .0; if visualize: figure(); for (phi_m, phi_idx) in zip(phis, xrange(N_phi)): Is = bins[phi_m]['Is'] unique_Is = bins[phi_m]['unique_Is'] N_Is = len(Is); Tf = amax(Is); a,b,g = abg[0], abg[1], abg[2] movingThreshold = getMovingThreshold(a,g, phi_m, binnedTrain.theta) def LHS(ts): LHS_numerator = movingThreshold(ts) *sqrt(2.) LHS_denominator = b * sqrt(1 - exp(-2*ts)) return 1 - norm.cdf(LHS_numerator / LHS_denominator); def RHS(ts): if False == iterable(ts): ts = array([ts]) lIs = tile(Is, len(ts) ).reshape((len(ts), len(Is))).transpose() lts = tile(ts, (len(Is),1 ) ) mask = lIs < lts taus = (lts - lIs); #*mask #NOTE BELOW WE use abs(taus) since for non-positive taus we will mask away anyway: numerator = (movingThreshold(lts) - movingThreshold(lIs)* exp(-abs(taus))) * sqrt(2.) denominator = b * sqrt(1. - exp(-2*abs(taus))) rhs = sum( (1. - norm.cdf(numerator/denominator))*mask, axis=0) / N_Is return rhs integrand = lambda t: (LHS(t) - RHS(t)) **2 dt = 1e-2; ts_manual = arange(1e-8, Tf+1e-2, dt ) integrand = LHS(ts_manual) - RHS(ts_manual) val = dot(integrand, integrand)*dt; weight = len(Is) lerror = val* weight; error += lerror if visualize: subplot(ceil(len(phis)/2),2, phi_idx+1); hold(True) # ts = linspace(1e-8, Tf+1e-8, 100) ; ts = unique_Is[1:]; lhs = LHS(ts); rhs = RHS(ts); plot(ts, lhs, 'b'); plot(ts, rhs, 'rx'); annotate('lerror = %.3g'%lerror,((min(ts), max(lhs)/2.)), ) if visualize: subplot(ceil(len(phis)/2),2,1); title(fig_tag) return error def loss_function_supnormalized(abg, visualize=False, fig_tag = ''): error = .0; if visualize: figure(); for (phi_m, phi_idx) in zip(phis, xrange(N_phi)): Is = bins[phi_m]['Is'] unique_Is = bins[phi_m]['unique_Is'] N_Is = len(Is); Tf = amax(Is); a,b,g = abg[0], abg[1], abg[2] movingThreshold = getMovingThreshold(a,g, phi_m, binnedTrain.theta) def LHS(ts): LHS_numerator = movingThreshold(ts) *sqrt(2.) LHS_denominator = b * sqrt(1 - exp(-2*ts)) return 1 - norm.cdf(LHS_numerator / LHS_denominator); def RHS(ts): if False == iterable(ts): ts = array([ts]) lIs = tile(Is, len(ts) ).reshape((len(ts), len(Is))).transpose() lts = tile(ts, (len(Is),1 ) ) mask = lIs < lts taus = (lts - lIs); #*mask #NOTE BELOW WE use abs(taus) since for non-positive taus we will mask away anyway: numerator = (movingThreshold(lts) - movingThreshold(lIs)* exp(-abs(taus))) * sqrt(2.) denominator = b * sqrt(1. - exp(-2*abs(taus))) rhs = sum( (1. - norm.cdf(numerator/denominator))*mask, axis=0) / N_Is return rhs dt = 1e-3; ts_manual = arange(1e-8, Tf+1e-2, dt) lhs = LHS(ts_manual) difference = abs(lhs - RHS(ts_manual))/amax(lhs) val = amax(difference); weight = len(Is) lerror = val* weight; error += lerror if visualize: subplot(ceil(len(phis)/2),2, phi_idx+1); hold(True) # ts = linspace(1e-8, Tf+1e-8, 100) ; ts = unique_Is[1:]; lhs = LHS(ts); rhs = RHS(ts); plot(ts, lhs, 'b'); plot(ts, rhs, 'rx'); annotate('lerror = %.3g'%lerror,((min(ts), max(lhs)/2.)), ) if visualize: subplot(ceil(len(phis)/2),2,1); title(fig_tag) return error def loss_function_sup(abg, visualize=False, fig_tag = ''): error = .0; if visualize: figure(); for (phi_m, phi_idx) in zip(phis, xrange(N_phi)): Is = bins[phi_m]['Is'] unique_Is = bins[phi_m]['unique_Is'] N_Is = len(Is); Tf = amax(Is); a,b,g = abg[0], abg[1], abg[2] movingThreshold = getMovingThreshold(a,g, phi_m, binnedTrain.theta) def LHS(ts): LHS_numerator = movingThreshold(ts) *sqrt(2.) LHS_denominator = b * sqrt(1 - exp(-2*ts)) return 1 - norm.cdf(LHS_numerator / LHS_denominator); def RHS(ts): if False == iterable(ts): ts = array([ts]) lIs = tile(Is, len(ts) ).reshape((len(ts), len(Is))).transpose() lts = tile(ts, (len(Is),1 ) ) mask = lIs < lts taus = (lts - lIs); #*mask #NOTE BELOW WE use abs(taus) since for non-positive taus we will mask away anyway: numerator = (movingThreshold(lts) - movingThreshold(lIs)* exp(-abs(taus))) * sqrt(2.) denominator = b * sqrt(1. - exp(-2*abs(taus))) rhs = sum( (1. - norm.cdf(numerator/denominator))*mask, axis=0) / N_Is return rhs dt = 1e-3; ts_manual = arange(1e-8, Tf+1e-2, dt) lhs = LHS(ts_manual) difference = abs(lhs - RHS(ts_manual)) val = amax(difference); weight = len(Is) lerror = val* weight; error += lerror if visualize: subplot(ceil(len(phis)/2),2, phi_idx+1); hold(True) # ts = linspace(1e-8, Tf+1e-8, 100) ; ts = unique_Is[1:]; lhs = LHS(ts); rhs = RHS(ts); plot(ts, lhs, 'b'); plot(ts, rhs, 'rx'); annotate('lerror = %.3g'%lerror,((min(ts), max(lhs)/2.)), ) if visualize: subplot(ceil(len(phis)/2),2,1); title(fig_tag) return error #EXPERIMENT: # Analyzer = DataAnalyzer() def outlinept(): pass analyzer = DataAnalyzer('FvsWF_4x16'); abg_true = analyzer.getTrueParamValues(regime_name) loss_function_L1(abg_true, visualize=True) return quad_estimated = analyzer.getEstimates(sample_id, regime_name, 'QuadFortet')[0] simple_estimated = analyzer.getEstimates(sample_id, regime_name, 'Fortet')[0] for abg, tag, L in zip(3*[abg_true, quad_estimated], ['sup_true_params' , 'sup_estimated_params', 'supnormailzed_true_params', 'supnormailzed_estimated_params', 'manualquad_true_params' , 'manualquad_estimated_params'], 2*[loss_function_sup]+ 2*[loss_function_supnormalized] + 2*[loss_function_manualquad]): start = time.clock() loss = L(abg,visualize, fig_tag = regime + '_' + tag); end = time.clock() print tag, ':%.2f,%.2f,%.2f:' %(abg[0],abg[1],abg[2]), 'error = %.4f'%loss , ' | compute time = ', end - start
def FortetHarness(): errors = [] for N_spikes, N_phi in zip( [100,1000], [8,20]): phi_norms = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) base_name = 'sinusoidal_spike_train_N=%d_'%N_spikes for regime in ['superT', 'crit', 'subT','superSin']: regime_label = base_name + regime for sample_id in [1,23, 36, 77, 99]: file_name = regime_label + '_' + str(sample_id) print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms) bins = binnedTrain.bins; phis = bins.keys() N_phi = len(phis) alpha, beta, gamma, theta = binnedTrain._Train._params.getParams() from scipy.stats.distributions import norm def loss_function_supnormalized(abg): error = .0; for (phi_m, phi_idx) in zip(phis, xrange(N_phi)): Is = bins[phi_m]['Is'] N_Is = len(Is); Tf = amax(Is); a,b,g = abg[0], abg[1], abg[2] movingThreshold = getMovingThreshold(a,g, phi_m,binnedTrain.theta) def LHS(ts): LHS_numerator = movingThreshold(ts) *sqrt(2.) LHS_denominator = b * sqrt(1 - exp(-2*ts)) return 1 - norm.cdf(LHS_numerator / LHS_denominator); def RHS(ts): if False == iterable(ts): ts = array([ts]) lIs = tile(Is, len(ts) ).reshape((len(ts), len(Is))).transpose() lts = tile(ts, (len(Is),1 ) ) mask = lIs < lts taus = (lts - lIs); #*mask #NOTE BELOW WE use abs(taus) since for non-positive taus we will mask away anyway: numerator = (movingThreshold(lts) - movingThreshold(lIs)* exp(-abs(taus))) * sqrt(2.) denominator = b * sqrt(1. - exp(-2*abs(taus))) rhs = sum( (1. - norm.cdf(numerator/denominator))*mask, axis=0) / N_Is return rhs ts_manual = linspace(1e-8, Tf+1e-2, 500) lhs = LHS(ts_manual) rhs = RHS(ts_manual) difference = abs(lhs - rhs)/amax(lhs) val = amax(difference); weight = len(Is) lerror = val* weight; error += lerror return error def closs_function(abg): error = .0; for (phi_m, phi_idx) in zip(phis, xrange(N_phi)): Is = bins[phi_m]['Is'] N_Is = len(Is); Tf = amax(Is); ts = linspace(1e-8, Tf+1e-2, 500) #Call C to compute the lhs - rhs abgthphi = r_[abg, theta, phi_m] difference = ext_fpc.FortetError(abgthphi, ts, Is) raw_error = amax(difference); weighted_error = N_Is * raw_error; error += weighted_error return error abg = array([alpha,beta,gamma]) start = time.clock() py_error = loss_function_supnormalized(abg) print 'pytime = ', time.clock() - start start = time.clock() c_error = closs_function(abg) print 'ctime = ', time.clock() - start errors.append([py_error, c_error]) pys = array(errors)[:,0] cs = array(errors)[:,1] figure(); hold(True) plot(pys, cs, '*'); plot(pys, pys, '-')
def writeManual(): from BinnedSpikeTrain import BinnedSpikeTrain from InitBox import initialize5 import time N_phi = 20; print 'N_phi = ', N_phi phis = linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi) h5file = openFile("manual_write.h5", mode = "w", title = "Manually Write Estimate Data") grp = h5file.createGroup("/", 'Estimates', "Estimates INformation") base_name = 'sinusoidal_spike_train_T=' for regime_name, T_sim, T_thresh in zip(['superT', 'subT', 'crit', 'superSin'], [5000 , 20000, 5000, 5000], [4., 32, 16., 16.]): estTable = h5file.createTable(grp, regime_name, Estimate , "Regime Estimate") # sampleTbl = h5file.createTable(grp, regime_name, Estimate , "Regime Estimate") regime_label = base_name + str(T_sim)+ '_' + regime_name for sample_id in xrange(1,3): file_name = regime_label + '_' + str(sample_id) + '.path' print file_name binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phis) ps = binnedTrain._Path._params abg_true = array((ps._alpha, ps._beta, ps._gamma)) if 1 == sample_id: print 'abg_true = ', abg_true phi_omit = None binnedTrain.pruneBins(phi_omit, N_thresh = 64, T_thresh=T_thresh) print 'N_bins = ', len(binnedTrain.bins.keys()) Tf = binnedTrain.getTf() print 'Tf = ', Tf #Estimate: estimate = estTable.row start = time.clock() abg_init = initialize5(binnedTrain) finish = time.clock() estimate['method'] = 'Initializer' estimate['sample_id'] = sample_id estimate['alpha'] = abg_init[0] estimate['beta'] = abg_init[1] estimate['gamma'] = abg_init[2] estimate['walltime'] = finish - start estimate.append() abg_est = abg_init start = time.clock() # abg_est = NMEstimator(S, binnedTrain, abg_init) time.sleep(rand()) print 'Est. time = ', time.clock() - start print 'abg_est = ', abg_est start = time.clock() # abg_est = FortetEstimator(binnedTrain, abg_init) time.sleep(2*rand()) print 'Est. time = ', time.clock() - start print 'abg_est = ', abg_est estTable.flush() print '#'*44 print h5file h5file.close()