def func(abg):
        xmin = FPMultiPhiSolver.calculate_xmin(S.getTf(), abg)
        dt = FPMultiPhiSolver.calculate_dt(S._dx, abg, xmin)
        S.rediscretize(S._dx, dt, S.getTf(), xmin)
        
        'Solve it:'
        Fss = S.c_solve(abg);
        Fs = Fss[:,:,-1];
        Ss = S.transformSurvivorData(binnedTrain)
        Ls = Fs - Ss
        
        'Return '
        G = .5*sum(Ls*Ls)*S._dt 
        
        print 'abg = ', abg, '; G=', G
#        G = .0;
#        for phi, phi_idx in zip(S._phis, xrange(S._num_phis() )):
#            unique_Is = bins[phi]['unique_Is']
#            SDF = bins[phi]['SDF']
#            Ls = SDF - interp(unique_Is, ts, Fs[phi_idx,:])
#            G += sum(Ls*Ls) 
        
        del Fss, Fs, Ss, Ls;
        
        return G
Example #2
0
    def func(abg):
        'rediscretize:'
        xmin = FPMultiPhiSolver.calculate_xmin(S.getTf(), abg, S._theta)
        dt = FPMultiPhiSolver.calculate_dt(S._dx, abg, xmin, factor = 2.)
#        print abg, dt, S._dx, xmin
        S.rediscretize(S._dx, dt, S.getTf(), xmin)
        
        'Solve it:'
#        print abg
#        start = time.clock()
        Fs = S.c_solve(abg)
#        solve_end = time.clock()
        spike_t_indexes = mleBinnedTrain.getTindxs(S._ts)
#        t_indxs_end = time.clock();
#        print abg, ' : solvetime = %f; indx_time = %f'%(solve_end  - start, t_indxs_end - solve_end) 
       
        'form (approximate) likelihood:'
        pdf = -diff(Fs[:,:,-1], axis = 1) / S._dt;
        likelihoods = pdf[minus_idxs, spike_t_indexes]*minus_weights + \
                      pdf[plus_idxs, spike_t_indexes]*plus_weights
        if amin(likelihoods) <= .0:
            likelihoods[likelihoods<=.0] = 1e-8
        
        'Return '
        return -sum(log(likelihoods))
    def func(abgt):
        'Solve it:'
        abg = abgt[:3]
        xmin = FPMultiPhiSolver.calculate_xmin(S.getTf(), abg)
        dt = FPMultiPhiSolver.calculate_dt(S._dx, abg, xmin)
        S.rediscretize(S._dx, dt, S.getTf(), xmin)
        
        Fs = S.solve_tau(abgt, visualize=False)[:,:,-1]
        Ss = S.transformSurvivorData(binnedTrain)
        Ls = Fs - Ss

        'Return '
        G = .5*sum(Ls*Ls)*S._dt 
        
        return G
Example #4
0
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 obtainRenewalDensities(phis, abg, theta, Tf):
    xmin = FPMultiPhiSolver.calculate_xmin(Tf, abg)
    dx = .025; dt = FPMultiPhiSolver.calculate_dt(dx, abg, xmin, factor = 5.)
    S = FPMultiPhiSolver(theta, phis,
                             dx, dt, Tf, xmin);
      
    Fs = S.solve(abg)
    ts = S._ts;
            
    iG = squeeze(Fs[:, :,-1])
    
    g = -diff(iG)/ S._dt;
    
    t_mids = (S._ts[1:]+S._ts[:-1])/2.0
    
    return g, S._ts ,t_mids
    def func(abg):
        xmin = FPMultiPhiSolver.calculate_xmin(S.getTf(), abg, S._theta)
        dt = FPMultiPhiSolver.calculate_dt(S._dx, abg, xmin)
        S.rediscretize(S._dx, dt, S.getTf(), xmin)
        
        'Solve it:'
        Fss = S.c_solve(abg)
        Fs = Fss[:,:,-1]
        Ss = S.transformSurvivorData(binnedTrain)
        lSups = amax(abs(Fs - Ss) , axis = 1)

        'Return '
        G = dot(weight_vector, lSups)
        
        if verbose:
            print 'abg = ', abg, '; G=', G
        return G
Example #7
0
            def loglikelihood(abg):     
                'rediscretize:'
                xmin = FPMultiPhiSolver.calculate_xmin(S.getTf(), abg, S._theta)
                dt = FPMultiPhiSolver.calculate_dt(S._dx, abg, xmin)
                S.rediscretize(S._dx, dt, S.getTf(), xmin)
                'Solve it:'
                Fs = S.c_solve(abg)
                spike_t_indexes = mleBinnedTrain.getTindxs(S._ts)
                'form (approximate) likelihood:'
                pdf = -diff(Fs[:,:,-1], axis = 1) / S._dt;
                likelihoods = pdf[minus_idxs, spike_t_indexes]*minus_weights +\
                              pdf[plus_idxs, spike_t_indexes]*plus_weights
#                if amin(likelihoods) <= .0:
#                    likelihoods[likelihoods<=.0] = 1e-8
                normalized_log_likelihood = sum(log(likelihoods))
                'Return '
                return -normalized_log_likelihood
Example #8
0
 def _resetSolver(self):
     abg = self._abg_current
     max_speed = abg[0] + abs(abg[2]) - self._Solver._xs[0];
     dx = abg[1] / max_speed / 1e2
     dt = FPMultiPhiSolver.calculate_dt(dx, max_speed, 1e2)
     
     Tf = self._Solver.getTf()
     self._Solver.rediscretize(dx, dt, Tf)
Example #9
0
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'
Example #10
0
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 func(abg):
        xmin = FPMultiPhiSolver.calculate_xmin(S.getTf(), abg)
        dt = FPMultiPhiSolver.calculate_dt(S._dx, abg, xmin)
        S.rediscretize(S._dx, dt, S.getTf(), xmin)
        
        'Solve it:'
        Fss = S.c_solve(abg)
        Fs = Fss[:,:,-1]
        Ss = S.transformSurvivorData(binnedTrain)
        Ls = Fs - Ss

        'Return '
        G = .5*sum( dot(weight_vector, Ls*Ls) )*S._dt / sum(weight_vector)
        
#        'clean up'
#        del Fss, Fs, Ss, Ls;
        
        print 'abg = ', abg, '; G=', G
        return G
Example #12
0
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'
Example #13
0
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
Example #14
0
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  
Example #15
0
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 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 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
Example #18
0
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 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
Example #20
0
def MixedEstimator(abg_init, binnedTrain, dp_tol = 1e-2):
    phis = binnedTrain.bins.keys();
    theta = binnedTrain.theta

    dp = dp_tol*2.0;
    abg = abg_init
    
    while dp > dp_tol:
        Tf = binnedTrain.getTf()
   
        xmin = FPMultiPhiSolver.calculate_xmin(Tf, abg)
        dx = FPMultiPhiSolver.calculate_dx(abg, xmin)
        dt = FPMultiPhiSolver.calculate_dt(dx, abg, xmin, factor = 8.)

        S = FPMultiPhiSolver(theta, phis,
                             dx, dt, Tf, xmin)

        Fs = S.solve(abg, visualize=False)
        Ss = S.transformSurvivorData(binnedTrain)
        Ls = Fs[:,:,-1] - Ss
        Nus = S.solveAdjoint(abg, Ls)
    
        dGdp = S.estimateParameterGradient(abg, Fs, Nus)

        from numpy.linalg.linalg import norm
        
        dG_normalized = dGdp/ norm(dGdp) 
        
        dp = FortetLineEstimator(binnedTrain, abg, dG_normalized, dp_tol)
        
        abg = abg - dp*dG_normalized

        print 'dG = ', dG_normalized
        print 'dp = ', dp
        print 'abg = (%.3g, %.3g, %.3g)'%(abg[0],abg[1],abg[2])
        print '-'

    return abg
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 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
Example #23
0
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
Example #24
0
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);
Example #25
0
def supersin_sandbox(N_phi = 32):
    N_sub_samples = 10
    N_samples = N_sub_samples*5;

    normalized_phis =  linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi)
    
    #results banks:
    likelihoods = empty((4, 4, N_samples))
    errors = empty((4, 3, N_samples))
    
    seed(2013)
    for regime_idx, tag in enumerate(['superSin']):
        file_name = 'sinusoidal_spike_train_N=1000_%s_22'%(tag)
        print file_name
        binnedTrain = BinnedSpikeTrain.initFromFile(file_name, normalized_phis)
        theta = binnedTrain.theta;
        real_phis = normalized_phis * 2.0 * pi / theta;
    
        for sample_idx in xrange(N_samples):
            if 0 == mod(sample_idx, N_sub_samples):
                train_id = randint(1,101) 
                file_name = 'sinusoidal_spike_train_N=1000_%s_%d'%(tag, train_id)
                print file_name
                binnedTrain = BinnedSpikeTrain.initFromFile(file_name, normalized_phis)
                
            phi_star,I_star = binnedTrain.getRandomPhiInterval()
            print 'phi_star_normalized, I_star: %.3f, %.3f' %(phi_star/ (2*pi/theta), I_star)
            
            phi_m, phi_minus, phi_plus = getApproximatePhis(phi_star, real_phis,theta)
            delta_phi_minus_weight, delta_phi_plus_weight = getDeltaPhiWeights(phi_star, phi_minus, phi_plus)
            
            #phi_star_idx = 0; phi_m_idx = 1; etc...
            solver_phis = [phi_star, phi_m, phi_minus, phi_plus]
#            print 'solver_phis = ', solver_phis
#            print 'weights = %.3f, %.3f'%(delta_phi_minus_weight, delta_phi_plus_weight)   
            
            ps = binnedTrain._Train._params
            abg_true = array((ps._alpha, ps._beta, ps._gamma))
            
            abg = abg_true
            
            Tf = I_star + .2;
            
            dx = .025; 
            x_min = FPMultiPhiSolver.calculate_xmin(Tf, abg, theta)
            dt = FPMultiPhiSolver.calculate_dt(dx,abg, x_min, factor = 1.0)
            
            S = FPMultiPhiSolver(theta, solver_phis,
                                    dx, dt, Tf, x_min)
            S.setTf(Tf)
            
            Fs =  S.c_solve(abg)
            Fth = Fs[:,:,-1]
            Fth_phis = S.solveFphi(abg, Fs)[:,:,-1]
            ts = S._ts;
            
            tm_idx, tp_idx = gettsIndex(ts, I_star)
            delta_t = S._dt
            delta_phi = phi_star - phi_m
            
            #various approximations to the likelihood, L
            L_star = -diff(Fth[0, [tm_idx, tp_idx]]) / (delta_t)
            L_m    = -diff(Fth[1, [tm_idx, tp_idx]]) / (delta_t)
            L_plus_minus    = -(diff(Fth[2, [tm_idx, tp_idx]])*delta_phi_minus_weight + \
                                  diff(Fth[3, [tm_idx, tp_idx]])*delta_phi_plus_weight)/ (delta_t)
            gradphi_g = -diff(Fth_phis[1, [tm_idx, tp_idx]]) / (delta_t);
            logL_gradphi = log(L_m) +  delta_phi * gradphi_g / L_m
            L_gradphi = exp(logL_gradphi)  
            
            'sanity check'
            approx_Fth_phi = .5 * sum(Fth[0, [tm_idx, tp_idx]] - Fth[1, [tm_idx, tp_idx]]) / (phi_star - phi_m)
            lFth_phi = .5* (sum(Fth_phis[1, [tm_idx, tp_idx]]))  
            if (approx_Fth_phi * lFth_phi < .0):
                print 'sanity inverse: approx:%.3f , adjoint_calc: %.3f'%(approx_Fth_phi,lFth_phi) 
            
            if (.0 >= L_star*L_m*L_plus_minus*L_gradphi):
                print 'negative likelihood encountered'
#            print 'di_F: %.4f,%.4f,%.4f' %(diF_star, diF_m, diF_plus_minus)
#            print 'error: %.4f,%.4f' %(abs(diF_star - diF_m), abs(diF_star-diF_plus_minus) )
            
            likelihoods[regime_idx, :, sample_idx] = r_[L_star,
                                                         L_m,
                                                          L_plus_minus,
                                                          L_gradphi]
            errors[regime_idx, :, sample_idx] = r_[abs(L_star - L_m),
                                                    abs(L_star-L_plus_minus),
                                                    abs(L_star - L_gradphi)]
            
        figure()
        plot(errors[regime_idx, 0,:], 'b', label='F_m')
        plot(errors[regime_idx, 1,:], 'r', label='F_min + F_plus')
        legend(); title(tag, fontsize = 32)
    
    from numpy import save
    save('likelihoods_supersin',likelihoods)
    save('errors_supersin', errors)
Example #26
0
def thetas_sandbox(save_figs=False):
    N_samples = 100;
    N_phi = 64;
    normalized_phis =  linspace(1/(2.*N_phi), 1. - 1/ (2.*N_phi), N_phi)
    
    #results banks:
#    seed(2013)
    thetas = [10, 20]
    likelihoods = empty((len(thetas), 4, N_samples))
    errors = empty((len(thetas), 3, N_samples))
    
    base_name = 'sinusoidal_spike_train_N=1000_critical_theta='
    for regime_idx, theta in enumerate(thetas):    
        sample_id = 17
        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, normalized_phis)
        theta = binnedTrain.theta;
        real_phis = normalized_phis * 2.0 * pi / theta;
        
        for sample_idx in xrange(N_samples): 
            phi_star,I_star = binnedTrain.getRandomPhiInterval()
            print 'phi_star_normalized, I_star: %.3f, %.3f' %(phi_star/ (2*pi/theta), I_star)
            
            phi_m, phi_minus, phi_plus = getApproximatePhis(phi_star, real_phis,theta)
            delta_phi_minus_weight, delta_phi_plus_weight = getDeltaPhiWeights(phi_star, phi_minus, phi_plus)
            
            #phi_star_idx = 0; phi_m_idx = 1; etc...
            solver_phis = [phi_star, phi_m, phi_minus, phi_plus]
#            print 'solver_phis = ', solver_phis
#            print 'weights = %.3f, %.3f'%(delta_phi_minus_weight, delta_phi_plus_weight)   
            
            ps = binnedTrain._Train._params
            abg_true = array((ps._alpha, ps._beta, ps._gamma))
            
            abg = abg_true
            
            Tf = I_star + .2;
            
            dx = .025; 
            x_min = FPMultiPhiSolver.calculate_xmin(Tf, abg, theta)
            dt = FPMultiPhiSolver.calculate_dt(dx,abg, x_min, factor = 1.0)
            
            S = FPMultiPhiSolver(theta, solver_phis,
                                    dx, dt, Tf, x_min)
            S.setTf(Tf)
            
            Fs =  S.c_solve(abg)
            Fth = Fs[:,:,-1]
#            Fth_phis = S.solveFphi(abg, Fs)[:,:,-1]
            ts = S._ts;
            
            tm_idx, tp_idx = gettsIndex(ts, I_star)
            delta_t = S._dt
            delta_phi = phi_star - phi_m
            
            #various approximations to the likelihood, L
            L_star = -diff(Fth[0, [tm_idx, tp_idx]]) / (delta_t)
            L_m    = -diff(Fth[1, [tm_idx, tp_idx]]) / (delta_t)
            L_plus_minus    = -(diff(Fth[2, [tm_idx, tp_idx]])*delta_phi_minus_weight + \
                                  diff(Fth[3, [tm_idx, tp_idx]])*delta_phi_plus_weight)/ (delta_t)
#            gradphi_g = -diff(Fth_phis[1, [tm_idx, tp_idx]]) / (delta_t);
#            logL_gradphi = log(L_m) +  delta_phi * gradphi_g / L_m
#            L_gradphi = exp(logL_gradphi)
            L_gradphi = L_plus_minus
              
            
#            print 'di_F: %.4f,%.4f,%.4f' %(diF_star, diF_m, diF_plus_minus)
#            print 'error: %.4f,%.4f' %(abs(diF_star - diF_m), abs(diF_star-diF_plus_minus) )
            
            likelihoods[regime_idx, :, sample_idx] = r_[L_star,
                                                         L_m,
                                                          L_plus_minus,
                                                           L_gradphi]
            errors[regime_idx, :, sample_idx] = r_[abs(L_star - L_m),
                                                    abs(L_star-L_plus_minus),
                                                    abs(L_star - L_gradphi)]
            
        figure()
        plot(errors[regime_idx, 0,:], 'b', label='F_m')
        plot(errors[regime_idx, 1,:], 'r', label='F_min + F_plus')
        legend(); title('theta= %.2f'%theta, fontsize = 32)
    
    from numpy import save
    save('likelihoods_thetas',likelihoods)
    save('errors_thetas', errors)
Example #27
0
def adapted_sandbox(save_figs=False):
#    file_name = 'sinusoidal_spike_train_N=1000_subT_11'
#    file_name = 'sinusoidal_spike_train_N=1000_superSin_13'
    N_samples = 16;

    N_phi_per_quarter = 4;
    N_phi = 4*N_phi_per_quarter;
    normalized_phis =  getAdaptedPhis(N_phi_per_quarter) 
    diFs = empty((4, 3, N_samples))
    errors = empty((4, 2, N_samples))
    
    seed(2013)
    for regime_idx, tag in enumerate(['superSin', 'crit', 'superT', 'subT']):
        file_name = 'sinusoidal_spike_train_N=1000_%s_13'%tag
        binnedTrain = BinnedSpikeTrain.initFromFile(file_name, normalized_phis)
        theta = binnedTrain.theta;
        real_phis = normalized_phis * 2.0 * pi / theta;
                
        for sample_idx in xrange(N_samples): 
            phi_star,I_star = binnedTrain.getRandomPhiInterval()
            
            print 'phi_star, I_star: ', phi_star, I_star
            
            phi_m, phi_minus, phi_plus = getApproximatePhis(phi_star, real_phis,theta)
            delta_phi_minus_weight, delta_phi_plus_weight = getDeltaPhiWeights(phi_star, phi_minus, phi_plus)
            
            solver_phis = [phi_star, phi_m, phi_minus, phi_plus]
            
            ps = binnedTrain._Train._params
            abg = array((ps._alpha, ps._beta, ps._gamma))
            
            Tf = I_star + .2;
            
            dx = .025; 
            x_min = FPMultiPhiSolver.calculate_xmin(Tf, abg, theta)
            dt = FPMultiPhiSolver.calculate_dt(dx,abg, x_min, factor = 1.0)
            
            S = FPMultiPhiSolver(theta, solver_phis,
                                    dx, dt, Tf, x_min)
            S.setTf(Tf)
            
            Fth = S.c_solve(abg)[:,:,-1]
            ts = S._ts;
            
            tm_idx, tp_idx = gettsIndex(ts, I_star)
            
            diF_star = -diff(Fth[0, [tm_idx, tp_idx]]) / (S._dt)
            diF_m    = -diff(Fth[1, [tm_idx, tp_idx]]) / (S._dt)
            diF_plus_minus    = -(diff(Fth[2, [tm_idx, tp_idx]])*delta_phi_minus_weight + \
                                  diff(Fth[3, [tm_idx, tp_idx]])*delta_phi_plus_weight)/ (S._dt)
            
#            print 'di_F: %.4f,%.4f,%.4f' %(diF_star, diF_m, diF_plus_minus)
#            print 'error: %.4f,%.4f' %(abs(diF_star - diF_m), abs(diF_star-diF_plus_minus) )
            
            diFs[regime_idx, :, sample_idx] = r_[diF_star, diF_m, diF_plus_minus]
            errors[regime_idx, :, sample_idx] = r_[abs(diF_star - diF_m), abs(diF_star-diF_plus_minus)]
            
        figure()
        plot(errors[regime_idx, 0,:], 'b', label='F_m')
        plot(errors[regime_idx, 1,:], 'r', label='F_min + F_plus')
        legend(); title(tag, fontsize = 32)
    
    from numpy import save
    save('Ls_adapted',diFs)
    save('errors_adapted', errors)
def AdjointEstimator():
    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_crit_1'
    print file_name
    
    binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phis)
    
    phi_omit = None
    binnedTrain.pruneBins(phi_omit, N_thresh = 100, T_thresh = 10.0)
    print 'N_bins = ', len(binnedTrain.bins.keys())
    
    Tf = binnedTrain.getTf()
    print 'Tf = ', Tf
        
    phis = binnedTrain.bins.keys();
    theta = binnedTrain.theta
    
    
    ps = binnedTrain._Train._params
    abg_true = array((ps._alpha, ps._beta, ps._gamma))
    print 'abg_true = ', abg_true
    
    abg = abg_true
    xmin = FPMultiPhiSolver.calculate_xmin(Tf, abg)
    dx = FPMultiPhiSolver.calculate_dx(abg, xmin)
    dt = FPMultiPhiSolver.calculate_dt(dx, abg, xmin, factor = 8.)
    print 'xmin, dx, dt = ', xmin, dx, dt
    S = FPMultiPhiSolver(theta, phis,
                     dx, dt, Tf, xmin)

    abg_init = initialize5(binnedTrain)
    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
    
#    start = time.clock()
#    abg_est = NMEstimator(S, binnedTrain, abg_init)
#    print 'Est. time = ', time.clock() - start
#    print 'abg_est = ', abg_est
#
#    start = time.clock()
#    abg_est = COBYLAEstimator(S, binnedTrain, abg_init)
#    print 'Est. time = ', time.clock() - start
#    print 'abg_est = ', abg_est

#    start = time.clock()
#    abg_est = CGEstimator(S, binnedTrain, abg_init)
#    print 'Est. time = ', time.clock() - start
#    print 'abg_est = ', abg_est

    start = time.clock()
    abg_est = BFGSEstimator(S, binnedTrain, abg_init)
    print 'Est. time = ', time.clock() - start
    print 'abg_est = ', abg_est
Example #29
0
def MLEBox(N_spikes = 1000, N_trains=5, N_phi=16):
    print 'N_phi = ', N_phi
    
    N_phi_init = 8;
    phi_norms_init =  linspace(1/(2.*N_phi_init), 1. - 1/ (2.*N_phi_init), N_phi_init)

#    base_name = 'sinusoidal_spike_train_N=%d_'%N_spikes
#    output_file = open('mlebox_output.txt', 'w')
#    for regime_name, T_thresh in zip(['subT', 'crit', 'superSin','superT'],
#                                     [128., 64., 64., 64.]):
    output_file = open('mlebox_output_thetas.txt', 'w')
    thetas = [20]
    base_name = 'sinusoidal_spike_train_N=%d_critical_theta='%N_spikes
    T_thresh = 64.
    for theta in thetas:    
        for sample_id in xrange(1,N_trains +1):
            regime_name = 'theta%d'%theta
            regime_label = base_name + '%d'%theta            
            file_name = regime_label + '_%d'%sample_id
            print file_name
                        
#        regime_label = base_name + regime_name
#            file_name = regime_label + '_' + str(sample_id)
#            print file_name
            
            binnedTrain = BinnedSpikeTrain.initFromFile(file_name, phi_norms_init)
            ps = binnedTrain._Train._params
            abg_true = array((ps._alpha, ps._beta, ps._gamma))
        
            binnedTrain.pruneBins(None, N_thresh = 8, T_thresh=T_thresh)
            abg_init = initialize_right_2std(binnedTrain)
            abg_init[1] = amax([.1, abg_init[1]])
            abg_init[2] = amax([.0, abg_init[2]])

            abg_fortet, warnflag = FortetEstimatorSup(binnedTrain, abg_init)
            
            #RELOAD ALL DATA:               
            mleBinnedTrain = MLEBinnedSpikeTrain.initFromFile(file_name,
                                                              N_phi)
            
            #MLE F-P:
            dx = .025; dt = FPMultiPhiSolver.calculate_dt(dx, abg_true, -1.0) 
            phis = mleBinnedTrain.phi_ms;
            S = FPMultiPhiSolver(binnedTrain.theta, phis,
                                 dx, dt,
                                 binnedTrain.getTf(), X_min = -1.0)
            
            minus_idxs = mleBinnedTrain.phi_minus_indxs
            plus_idxs  = mleBinnedTrain.phi_plus_indxs
            minus_weights = mleBinnedTrain.phi_minus_weights
            plus_weights  = mleBinnedTrain.phi_plus_weights
            
            def loglikelihood(abg):     
                'rediscretize:'
                xmin = FPMultiPhiSolver.calculate_xmin(S.getTf(), abg, S._theta)
                dt = FPMultiPhiSolver.calculate_dt(S._dx, abg, xmin)
                S.rediscretize(S._dx, dt, S.getTf(), xmin)
                'Solve it:'
                Fs = S.c_solve(abg)
                spike_t_indexes = mleBinnedTrain.getTindxs(S._ts)
                'form (approximate) likelihood:'
                pdf = -diff(Fs[:,:,-1], axis = 1) / S._dt;
                likelihoods = pdf[minus_idxs, spike_t_indexes]*minus_weights +\
                              pdf[plus_idxs, spike_t_indexes]*plus_weights
#                if amin(likelihoods) <= .0:
#                    likelihoods[likelihoods<=.0] = 1e-8
                normalized_log_likelihood = sum(log(likelihoods))
                'Return '
                return -normalized_log_likelihood
            #MLE F-P:
#            abg_tnc, abg_cobyla, abg_neldermead = MLEEstimator(S,
#                                                             mleBinnedTrain, abg_init)
            abg_neldermead = MLEEstimator(S,mleBinnedTrain, abg_init)
            #OUTPUTs
            output_file.write('\n' +file_name + ':\n')
            for tag, abg in zip(['init', 'fortet', 'nelder_mead', 'true'],
                                [abg_init, abg_fortet, abg_tnc,
                                 abg_cobyla, abg_neldermead , abg_true]):
                output_file.write(tag + ':' + str(loglikelihood(abg)) + ':' + str(abg) + '\n');
def BFGSItersComparison():
    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('BFGS_Iters')
    for regime_name, T_sim, T_thresh in zip(['crit', 'superSin'],
                                                       [5000, 5000],
                                                       [16., 16.]):

        regime_label = base_name + str(T_sim)+ '_' + regime_name
            
        for sample_id in xrange(1,4):
            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 = .025; dt = FPMultiPhiSolver.calculate_dt(dx, 5., 2.)
        
            phis = binnedTrain.bins.keys();
            theta = binnedTrain.theta
            
            S = FPMultiPhiSolver(theta, phis,
                                 dx, dt,
                                 Tf, X_MIN = -2.0)
        
            start = time.clock()
            abg_init = initialize5(binnedTrain)
            finish = time.clock()
            D.addEstimate(sample_id, 'Initializer', abg_init, finish-start) 
                    
            start = time.clock()
            abg_est = BFGSEstimator(S, binnedTrain, abg_init, max_iters = 8)
            finish = time.clock()
            D.addEstimate(sample_id, 'BFGS_8', abg_est, finish-start) 
            
            start = time.clock()
            abg_est = BFGSEstimator(S, binnedTrain, abg_est,max_iters = 8)
            finish = time.clock()
            D.addEstimate(sample_id, 'BFGS_16', abg_est, finish-start)
            
            start = time.clock()
            abg_est = BFGSEstimator(S, binnedTrain, abg_est,max_iters = 8)
            finish = time.clock()
            D.addEstimate(sample_id, 'BFGS_24', abg_est, finish-start)
            
    D.closeFile() 
   
    print 'batch time = ', (time.clock() - batch_start) / 3600.0, ' hrs'