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)
