def generate_wfpt_reg_stochastic_class(wiener_params=None, sampling_method='cdf', cdf_range=(-5,5), sampling_dt=1e-4):
#set wiener_params
if wiener_params is None:
wiener_params = {'err': 1e-4, 'n_st':2, 'n_sz':2,
'use_adaptive':1,
'simps_err':1e-3,
'w_outlier': 0.1}
wp = wiener_params
def wiener_multi_like(value, v, sv, a, z, sz, t, st, reg_outcomes, p_outlier=0):
"""Log-likelihood for the full DDM using the interpolation method"""
return hddm.wfpt.wiener_like_multi(value, v, sv, a, z, sz, t, st, .001, reg_outcomes, p_outlier=p_outlier)
def random(v, sv, a, z, sz, t, st, reg_outcomes, p_outlier, size=None):
param_dict = {'v':v, 'z':z, 't':t, 'a':a, 'sz':sz, 'sv':sv, 'st':st}
sampled_rts = np.empty(size)
for i_sample in xrange(len(sampled_rts)):
#get current params
for p in reg_outcomes:
param_dict[p] = locals()[p][i_sample]
#sample
sampled_rts[i_sample] = hddm.generate.gen_rts(param_dict, method=sampling_method,
samples=1, dt=sampling_dt)
return sampled_rts
return pm.stochastic_from_dist('wfpt_reg', wiener_multi_like, random=random)
def inference_model(spread, y_with_outlier):
outlier_points = pymc.Uniform('outlier_points', 0, 1.0, value=0.1)
mean_outliers = pymc.Uniform('mean_outliers', -100, 100, value=0)
spread_outliers = pymc.Uniform('spread_outliers', -100, 100, value=0)
@pymc.stochastic
def slope_and_intercept(value=[1., 10.]):
slope, intercept = value
prob_slope = np.log(1. / (1. + slope ** 2))
return prob_slope
@pymc.deterministic
def model_(x=x, slope_and_intercept=slope_and_intercept):
slope, intercept = slope_and_intercept
fit = slope * x + intercept
return fit
inlier = pymc.Bernoulli('inlier', p=1 - outlier_points, value=np.zeros(x.size))
def log_posterior_likelihood_of_outlier(y_with_outlier, mu, spread, inlier, mean_outliers, spread_outliers):
inlier_posterior = np.sum(inlier * (np.log(2 * np.pi * spread ** 2) + (y_with_outlier - mu) ** 2 / (spread ** 2)))
outlier_posterior = np.sum((1 - inlier) * (np.log(2 * np.pi * ((spread ** 2) + (spread_outliers ** 2))) + (y_with_outlier - mean_outliers) ** 2 / ((spread ** 2) + (spread_outliers ** 2))))
return -0.5 * (inlier_posterior + outlier_posterior)
outlier_distribution = pymc.stochastic_from_dist('outlier_distribution', logp=log_posterior_likelihood_of_outlier, dtype=np.float, mv=True)
outlier_dist = outlier_distribution('outlier_dist', value=y_with_outlier, mu=model_, spread=spread, mean_outliers=mean_outliers, spread_outliers=spread_outliers, inlier=inlier, observed=True)
return locals()
def inference_outliers(self, x_array, y_array, m_0, n_0, spread_vector):
outlier_points = Uniform('outlier_points', 0, 1.0, value=0.1)
mean_outliers = Uniform('mean_outliers', -100, 100, value=0)
spread_outliers = Uniform('spread_outliers', -100, 100, value=0)
@stochastic
def slope_and_intercept(slope = m_0):
prob_slope = nplog(1. / (1. + slope ** 2))
return prob_slope
@deterministic
def model_(x=x_array, slope_and_intercept=slope_and_intercept):
slope, intercept = slope_and_intercept
fit = slope * x + intercept
return fit
inlier = Bernoulli('inlier', p=1 - outlier_points, value=zeros(x_array.size))
def log_posterior_likelihood_of_outlier(y_with_outlier, mu, spread_vector, inlier, mean_outliers, spread_outliers):
inlier_posterior = sum(inlier * (nplog(2 * pi * spread_vector ** 2) + (y_with_outlier - mu) ** 2 / (spread_vector ** 2)))
outlier_posterior = sum((1 - inlier) * (nplog(2 * pi * ((spread_vector ** 2) + (spread_outliers ** 2))) + (y_with_outlier - mean_outliers) ** 2 / ((spread_vector ** 2) + (spread_outliers ** 2))))
return -0.5 * (inlier_posterior + outlier_posterior)
outlier_distribution = stochastic_from_dist('outlier_distribution', logp=log_posterior_likelihood_of_outlier, dtype=npfloat, mv=True)
outlier_dist = outlier_distribution('outlier_dist', mu=model_, spread_vector=spread_vector, mean_outliers=mean_outliers, spread_outliers=spread_outliers, inlier=inlier, value=y_array, observed=True)
return locals()
def pymc_linear_fit_perpointoutlier(data1, data2, data1err=None, data2err=None):
"""
Model 3 from http://astroml.github.com/book_figures/chapter8/fig_outlier_rejection.html
*IGNORES X ERRORS*
"""
if data1err is not None:
raise NotImplementedError("Currently this form of outlier rejection ignores X errors")
# Third model: marginalizes over the probability that each point is an outlier.
# define priors on beta = (slope, intercept)
@pymc.stochastic
def beta_M2(value=np.array([2., 100.])):
"""Slope and intercept parameters for a straight line.
The likelihood corresponds to the prior probability of the parameters."""
slope, intercept = value
prob_intercept = 1 + 0 * intercept
# uniform prior on theta = arctan(slope)
# d[arctan(x)]/dx = 1 / (1 + x^2)
prob_slope = np.log(1. / (1. + slope ** 2))
return prob_intercept + prob_slope
@pymc.deterministic
def model_M2(xi=data1, beta=beta_M2):
slope, intercept = beta
return slope * xi + intercept
# qui is bernoulli distributed
qi = pymc.Bernoulli('qi', p=1 - Pb, value=np.ones(len(data1)))
def outlier_likelihood(yi, mu, dyi, qi, Yb, sigmab):
"""likelihood for full outlier posterior"""
Vi = dyi ** 2
Vb = sigmab ** 2
#root2pi = np.sqrt(2 * np.pi)
logL_in = -0.5 * np.sum(qi * (np.log(2 * np.pi * Vi)
+ (yi - mu) ** 2 / Vi))
logL_out = -0.5 * np.sum((1 - qi) * (np.log(2 * np.pi * (Vi + Vb))
+ (yi - Yb) ** 2 / (Vi + Vb)))
return logL_out + logL_in
OutlierNormal = pymc.stochastic_from_dist('outliernormal',
logp=outlier_likelihood,
dtype=np.float,
mv=True)
y_outlier = OutlierNormal('y_outlier', mu=model_M2, dyi=data2,
Yb=Yb, sigmab=sigmab, qi=qi,
observed=True, value=yi)
M2 = dict(y_outlier=y_outlier, beta_M2=beta_M2, model_M2=model_M2,
qi=qi, Pb=Pb, Yb=Yb, log_sigmab=log_sigmab, sigmab=sigmab)
def general_WienerCont(err=1e-4, nT=2, nZ=2, use_adaptive=1, simps_err=1e-3):
_like = lambda value, cont_x, v, V, a, z, Z, t, T, t_min, t_max, err=err, nT=nT, nZ=nZ, \
use_adaptive=use_adaptive, simps_err=simps_err: \
wiener_like_contaminant(value, cont_x, v, V, a, z, Z, t, T, t_min, t_max,\
err=err, nT=nT, nZ=nZ, use_adaptive=use_adaptive, simps_err=simps_err)
_like.__doc__ = wiener_like_contaminant.__doc__
return pm.stochastic_from_dist(name="Wiener Diffusion Contaminant Process",
logp=_like,
dtype=np.float,
mv=False)
def general_WienerCont(err=1e-4,
n_st=2,
n_sz=2,
use_adaptive=1,
simps_err=1e-3):
_like = lambda value, cont_x, v, sv, a, z, sz, t, st, t_min, t_max, err=err, n_st=n_st, n_sz=n_sz, \
use_adaptive=use_adaptive, simps_err=simps_err: \
wiener_like_contaminant(value, cont_x, v, sv, a, z, sz, t, st, t_min, t_max,\
err=err, n_st=n_st, n_sz=n_sz, use_adaptive=use_adaptive, simps_err=simps_err)
_like.__doc__ = wiener_like_contaminant.__doc__
return pm.stochastic_from_dist(name="Wiener Diffusion Contaminant Process",
logp=_like,
dtype=np.float,
mv=False)
def _getMCPosterior(self, y_with_outlier, x):
m, c = self._getMCPrior(y_with_outlier, x)
slope = pymc.Uniform('slope', m - self._slope_range,
m + self._slope_range)
def log_posterior_likelihood_of_slope(y_with_outlier, slope):
y_corrected = self._correctY(y_with_outlier, x, slope, 0)
y_density = gaussian_kde(y_corrected)
y_down = min(y_corrected)
y_up = max(y_corrected)
y_xs = np.linspace(y_down, y_up,
1000 * self._tau * self._max_copynumber)
y_ys = y_density(y_xs)
peaks = argrelextrema(y_ys, np.greater)
prob = sum(heapq.nlargest(self._max_copynumber, y_ys[peaks[0]]))
return prob
slope_distribution = pymc.stochastic_from_dist(
'slope_distribution',
logp=log_posterior_likelihood_of_slope,
dtype=np.float,
mv=True)
slope_dist = slope_distribution('slope_dist',
slope=slope,
observed=True,
value=y_with_outlier)
model = dict(slope_dist=slope_dist, slope=slope)
M = pymc.MAP(model)
M.fit()
slope_best = M.slope.value
y_median = np.percentile(y_with_outlier, 50)
x_median = x[sum(y_with_outlier < y_median)]
intercept_best = y_median - slope_best * x_median
return slope_best, intercept_best
def generate_wfpt_reg_stochastic_class(wiener_params=None, sampling_method="cdf", cdf_range=(-5, 5), sampling_dt=1e-4):
# set wiener_params
if wiener_params is None:
wiener_params = {"err": 1e-4, "n_st": 2, "n_sz": 2, "use_adaptive": 1, "simps_err": 1e-3, "w_outlier": 0.1}
wp = wiener_params
def wiener_multi_like(value, v, sv, a, z, sz, t, st, reg_outcomes, p_outlier=0):
"""Log-likelihood for the full DDM using the interpolation method"""
return hddm.wfpt.wiener_like_multi(value, v, sv, a, z, sz, t, st, 0.001, reg_outcomes, p_outlier=p_outlier)
def random(v, sv, a, z, sz, t, st, reg_outcomes, p_outlier, size=None):
param_dict = {"v": v, "z": z, "t": t, "a": a, "sz": sz, "sv": sv, "st": st}
sampled_rts = np.empty(size)
for i_sample in xrange(len(sampled_rts)):
# get current params
for p in reg_outcomes:
param_dict[p] = locals()[p][i_sample]
# sample
sampled_rts[i_sample] = hddm.generate.gen_rts(param_dict, method=sampling_method, samples=1, dt=sampling_dt)
return sampled_rts
return pm.stochastic_from_dist("wfpt_reg", wiener_multi_like, random=random)
raise ObjectNotFound('%r does not name an object' % (name,))
obj = topLevelPackage
for n in names[1:]:
obj = getattr(obj, n)
return obj
######################
# END OF COPIED CODE #
######################
def centered_half_cauchy_rand(S, size):
"""sample from a half Cauchy distribution with scale S"""
return abs(S * np.tan(np.pi * pm.random_number(size) - np.pi/2.0))
def centered_half_cauchy_logp(x, S):
"""logp of half Cauchy with scale S"""
x = np.atleast_1d(x)
if sum(x<0): return -np.inf
return pm.flib.cauchy(x, 0, S) + len(x) * np.log(2)
HalfCauchy = pm.stochastic_from_dist(name="Half Cauchy",
random=centered_half_cauchy_rand,
logp=centered_half_cauchy_logp,
dtype=np.double)
if __name__ == "__main__":
import doctest
doctest.testmod()
np.array([
np.cos(x[1] * d2r) * np.cos(x[0] * d2r),
np.cos(x[1] * d2r) * np.sin(x[0] * d2r),
np.sin(x[1] * d2r)
]))
logp_elem = np.log( -kappa / ( 2. * np.pi * np.expm1(-2. * kappa)) ) + \
kappa * (np.dot(test_point, mu) - 1.)
logp = logp_elem.sum()
return logp
VonMisesFisher = pymc.stochastic_from_dist('von_mises_fisher',
logp=vmf_logp,
random=vmf_random,
dtype=np.float,
mv=True)
def spherical_beta_random(lon_lat, alpha):
# make the appropriate euler rotation matrix
beta = np.pi / 2. - lon_lat[1] * d2r
gamma = lon_lat[0] * d2r
rot_beta = np.array([[np.cos(beta), 0., np.sin(beta)], [0., 1., 0.],
[-np.sin(beta), 0., np.cos(beta)]])
rot_gamma = np.array([[np.cos(gamma), -np.sin(gamma), 0.],
[np.sin(gamma), np.cos(gamma), 0.], [0., 0., 1.]])
rotation_matrix = np.dot(rot_gamma, rot_beta)
# Generate samples around the z-axis, then rotate
np.cos(lon_lat[1] * d2r) * np.sin(lon_lat[0] * d2r),
np.sin(lon_lat[1] * d2r)])
test_point = np.transpose(np.array([np.cos(x[1] * d2r) * np.cos(x[0] * d2r),
np.cos(x[1] * d2r) *
np.sin(x[0] * d2r),
np.sin(x[1] * d2r)]))
logp_elem = np.log( -kappa / ( 2. * np.pi * np.expm1(-2. * kappa)) ) + \
kappa * (np.dot(test_point, mu) - 1.)
logp = logp_elem.sum()
return logp
VonMisesFisher = pymc.stochastic_from_dist('von_mises_fisher',
logp=vmf_logp,
random=vmf_random,
dtype=np.float,
mv=True)
def spherical_beta_random(lon_lat, alpha):
# make the appropriate euler rotation matrix
beta = np.pi / 2. - lon_lat[1] * d2r
gamma = lon_lat[0] * d2r
rot_beta = np.array([[np.cos(beta), 0., np.sin(beta)],
[0., 1., 0.],
[-np.sin(beta), 0., np.cos(beta)]])
rot_gamma = np.array([[np.cos(gamma), -np.sin(gamma), 0.],
[np.sin(gamma), np.cos(gamma), 0.],
[0., 0., 1.]])
rotation_matrix = np.dot(rot_gamma, rot_beta)
itau_stop, ip_tf):
"""Censored ExGaussian log-likelihood of SRRTs"""
return stop_likelihoods_wtf.SRRT(value, issd, imu_go, isigma_go, itau_go,
imu_stop, isigma_stop, itau_stop, ip_tf)
def cython_Inhibitions(value, imu_go, isigma_go, itau_go, imu_stop,
isigma_stop, itau_stop, ip_tf):
"""Censored ExGaussian log-likelihood of inhibitions"""
return stop_likelihoods_wtf.Inhibitions(value, imu_go, isigma_go, itau_go,
imu_stop, isigma_stop, itau_stop,
ip_tf)
Go_like = pm.stochastic_from_dist(name="Ex-Gauss GoRT",
logp=cython_Go,
dtype=np.float,
mv=False)
SRRT_like = pm.stochastic_from_dist(name="CensoredEx-Gauss SRRT",
logp=cython_SRRT,
dtype=np.float,
mv=False)
Inhibitions_like = pm.stochastic_from_dist(
name="CensoredEx-Gauss Inhibittions",
logp=cython_Inhibitions,
dtype=np.int32,
mv=False)
class KnodeGo(Knode):
import pymc as pm
import algorithms
from scipy import sparse
def mvn_logp(x,M,precision_products,backend):
"Takes a candidate value x, a mean vector M, the products returned by backend.precision_products as a map, and the linear algebra backend module. Passes the arguments to backend.mvn_logp and returns the log-probability of x given M and the precision matrix represented in precision_products."
if precision_products is None:
return -np.inf
else:
return backend.mvn_logp(x,M,**precision_products)
def rmvn(M,precision_products,backend):
"Takes a mean vector M, the products returned by backend.precision_products as a map, and the linear algebra backend module. Passes the arguments to backend.rmvn and returns a random draw x from the multivariate normal variable with mean M and the precision matrix represented in precision_products."
return backend.rmvn(M,**precision_products)
SparseMVN = pm.stochastic_from_dist('SparseMVN', mvn_logp, rmvn, mv=True)
class GMRFGibbs(pm.StepMethod):
def __init__(self, backend, x, obs, M, Q, Q_obs, L_obs=None, K_obs=None, pattern_products=None):
"""
Applies to the following conjugate submodel:
x ~ N(M,Q^{-1})
obs ~ N(L_obs x + K_obs, Q_obs^{-1})
Takes the following arguments:
- backend: A linear algebra backend, for example CHOLMOD
- x: a SparseMVN instance
- obs: A normal variable whose mean is a linear transformation of x.
- M: The prior mean of M.
- Q: The prior precision of M.
- Q_obs: The precision of obs conditional on x.
return np.exp(log_sigma)
@pymc.deterministic
def error(log_error=log_error):
return np.exp(log_error)
def gaussgauss_like(x, mu, sigma, error):
"""likelihood of gaussian with gaussian errors"""
sig2 = sigma ** 2 + error ** 2
x_mu2 = (x - mu) ** 2
return -0.5 * np.sum(np.log(sig2) + x_mu2 / sig2)
GaussGauss = pymc.stochastic_from_dist('gaussgauss',
logp=gaussgauss_like,
dtype=np.float,
mv=True)
M = GaussGauss('M', mu, sigma, error, observed=True, value=xi)
model = dict(mu=mu, log_sigma=log_sigma, sigma=sigma,
log_error=log_error, error=error, M=M)
#------------------------------------------------------------
# perform the MCMC sampling
pymc.numpy.random.seed(0)
S = pymc.MCMC(model)
S.sample(iter=25000, burn=2000)
#------------------------------------------------------------
# Extract the MCMC traces
trace_mu = S.trace('mu')[:]
@pymc.deterministic
def rate(r0=r0, a=a, omega=omega, phi=phi):
return rate_func(t, r0, a, omega, phi)
def arrival_like(obs, rate, Dt):
"""likelihood for arrival time"""
N = np.sum(obs)
return (N * np.log(Dt)
- np.sum(rate) * Dt
+ np.sum(np.log(rate[obs > 0])))
Arrival = pymc.stochastic_from_dist('arrival',
logp=arrival_like,
dtype=np.float,
mv=True)
obs_dist = Arrival('obs_dist', rate=rate, Dt=Dt, observed=True, value=obs)
model = dict(obs_dist=obs_dist, r0=r0, a=a, phi=phi,
log_omega=log_omega, omega=omega,
rate=rate)
#------------------------------------------------------------
# Compute results (and save to a pickle file)
@pickle_results('arrival_times.pkl')
def compute_model(niter=20000, burn=2000):
S = pymc.MCMC(model)
S.sample(iter=niter, burn=burn)
log_sigma = pymc.Uniform('log_sigma', -5, 5, value=0)
@pymc.deterministic
def sigma(log_sigma=log_sigma):
return np.exp(log_sigma)
def sigbg_like(x, A, x0, sigma):
"""signal + background likelihood"""
return np.sum(np.log(A * np.exp(-0.5 * ((x - x0) / sigma) ** 2)
/ np.sqrt(2 * np.pi) / sigma
+ (1 - A) / W_true))
SigBG = pymc.stochastic_from_dist('sigbg',
logp=sigbg_like,
dtype=np.float, mv=True)
M = SigBG('M', A, x0, sigma, observed=True, value=x)
model = dict(M=M, A=A, x0=x0, log_sigma=log_sigma, sigma=sigma)
#----------------------------------------------------------------------
# Run the MCMC sampling
S = pymc.MCMC(model)
S.sample(iter=25000, burn=5000)
#------------------------------------------------------------
# Plot the results
fig = plt.figure(figsize=(5, 5))
ax_list = plot_mcmc([S.trace(s)[:] for s in ['A', 'x0', 'sigma']],
import pycuda.cumath as cumath
import wfpt_gpu
gpu_imported = True
except:
gpu_imported = False
import hddm
def wiener_like_contaminant(value, cont_x, v, V, a, z, Z, t, T, t_min, t_max,
err, nT, nZ, use_adaptive, simps_err):
"""Log-likelihood for the simple DDM including contaminants"""
return hddm.wfpt.wiener_like_contaminant(value, cont_x.astype(np.int32), v, V, a, z, Z, t, T,
t_min, t_max, err, nT, nZ, use_adaptive, simps_err)
WienerContaminant = pm.stochastic_from_dist(name="Wiener Simple Diffusion Process",
logp=wiener_like_contaminant,
dtype=np.float,
mv=True)
def general_WienerCont(err=1e-4, nT=2, nZ=2, use_adaptive=1, simps_err=1e-3):
_like = lambda value, cont_x, v, V, a, z, Z, t, T, t_min, t_max, err=err, nT=nT, nZ=nZ, \
use_adaptive=use_adaptive, simps_err=simps_err: \
wiener_like_contaminant(value, cont_x, v, V, a, z, Z, t, T, t_min, t_max,\
err=err, nT=nT, nZ=nZ, use_adaptive=use_adaptive, simps_err=simps_err)
_like.__doc__ = wiener_like_contaminant.__doc__
return pm.stochastic_from_dist(name="Wiener Diffusion Contaminant Process",
logp=_like,
dtype=np.float,
mv=False)
class wfpt_gen(stats.distributions.rv_continuous):
wiener_params = {'err': 1e-4, 'nT':2, 'nZ':2,
def __init__(self, xi, yi, dyi, value):
self.xi, self.yi, self.dyi, self.value = xi, yi, dyi, value
@pymc.stochastic
def beta(value=np.array([0.5, 1.0])):
"""Slope and intercept parameters for a straight line.
The likelihood corresponds to the prior probability of the parameters."""
slope, intercept = value
prob_intercept = 1 + 0 * intercept
# uniform prior on theta = arctan(slope)
# d[arctan(x)]/dx = 1 / (1 + x^2)
prob_slope = np.log(1. / (1. + slope**2))
return prob_intercept + prob_slope
@pymc.deterministic
def model(xi=xi, beta=beta):
slope, intercept = beta
return slope * xi + intercept
# uniform prior on Pb, the fraction of bad points
Pb = pymc.Uniform('Pb', 0, 1.0, value=0.1)
# uniform prior on Yb, the centroid of the outlier distribution
Yb = pymc.Uniform('Yb', -10000, 10000, value=0)
# uniform prior on log(sigmab), the spread of the outlier distribution
log_sigmab = pymc.Uniform('log_sigmab', -10, 10, value=5)
# qi is bernoulli distributed
# Note: this syntax requires pymc version 2.2
qi = pymc.Bernoulli('qi', p=1 - Pb, value=np.ones(len(xi)))
@pymc.deterministic
def sigmab(log_sigmab=log_sigmab):
return np.exp(log_sigmab)
def outlier_likelihood(yi, mu, dyi, qi, Yb, sigmab):
"""likelihood for full outlier posterior"""
Vi = dyi**2
Vb = sigmab**2
root2pi = np.sqrt(2 * np.pi)
logL_in = -0.5 * np.sum(qi * (np.log(2 * np.pi * Vi) +
(yi - mu)**2 / Vi))
logL_out = -0.5 * np.sum(
(1 - qi) * (np.log(2 * np.pi * (Vi + Vb)) + (yi - Yb)**2 /
(Vi + Vb)))
return logL_out + logL_in
OutlierNormal = pymc.stochastic_from_dist('outliernormal',
logp=outlier_likelihood,
dtype=np.float,
mv=True)
y_outlier = OutlierNormal('y_outlier',
mu=model,
dyi=dyi,
Yb=Yb,
sigmab=sigmab,
qi=qi,
observed=True,
value=yi)
self.M = dict(y_outlier=y_outlier,
beta=beta,
model=model,
qi=qi,
Pb=Pb,
Yb=Yb,
log_sigmab=log_sigmab,
sigmab=sigmab)
self.sample_invoked = False
return (1./tau)**.5
def nre_like(x, mu, err):
'''Normal likelihood from relative error instead of tau'''
tau = sig2tau(mu*err)
#print x.shape, mu.shape, tau.shape
#print; print
return pm.normal_like(x, mu, tau)
def rnre(mu, err):
'''Random normal from relative error instead of tau'''
#if mu.shape[0]>1: size=
return pm.rnormal(mu, sig2tau(mu*err))
NormRelErr = pm.stochastic_from_dist("NormRelErr", logp=nre_like, random=rnre,
dtype=np.float,mv=False)
def sample_wr(population, size):
"""Chooses 'size' random elements (with replacement) from a population"""
n = len(population)
js = np.array(np.random.random(size) * n).astype('int')
return population[js]
def parm2ha(parm, ub, ub_type):
"""Convert parameter vector of an exhumation model [ e1, e2, e3, ... ,hc, abr1, abr2, ... ]
import pymc
import numpy as np
import bivariate_poisson_cython
def bivariate_poisson_like(values, l_1, l_2, l_3):
return bivariate_poisson_cython.bivariate_poisson_like(values[0],values[1], l_1, l_2, l_3)
def rbivariate_poisson(l_1,l_2,l_3):
l_1 = max(l_1,eps)
l_2 = max(l_2,eps)
l_3 = max(l_3,eps)
x = pymc.rpoisson(l_3)
return [pymc.rpoisson(l_1)+x,pymc.rpoisson(l_2)+x]
BivariatePoisson = pymc.stochastic_from_dist('BivariatePoisson', logp = bivariate_poisson_like, random = rbivariate_poisson, dtype=np.int, mv=True)
"""Compute synthetic likelihood for collapsing threshold wfpt."""
def mv_normal_like(s, mu, cov):
s = np.asmatrix(s)
mu = np.asmatrix(mu)
cov = np.asmatrix(cov)
return .5 * (s - mu) * (cov**-1) * (s - mu).T - .5 * np.log(np.linalg.det(cov))
true_sum = np.array((data.mean(), data.std())) #, np.sum(data), data.var()))
sum_stats = np.empty((samples, 2))
for sample in range(samples):
s = np.random.randn(dataset_samples)*std + mu
sum_stats[sample,:] = s.mean(), s.std() #, np.sum(s), s.var()
mean = np.mean(sum_stats, axis=0)
cov = np.cov(sum_stats.T)
# Evaluate synth likelihood
logp = mv_normal_like(true_sum, mean, cov)
return -logp
synth = pm.stochastic_from_dist(name="Wiener synthetic likelihood",
logp=synth_likelihood,
dtype=np.float32,
mv=False)
mu = pm.Uniform('mu', lower=-5, upper=5, value=0)
std = pm.Uniform('std', lower=.1, upper=2, value=1)
sl = synth('Synthetic likelihood', value=samples, mu=mu, std=std, observed=True)
#rl = pm.Normal('Regular likelihood', value=samples, mu=mu, tau=std**-2, observed=True)
Rshape = R.shape
R = np.atleast1d(R)
mask1 = (R < r1)
mask2 = ~mask1
N1 = mask1.sum()
N2 = R.size - N1
R[mask1] = norm(mu1, sigma1).rvs(N1)
R[mask2] = norm(mu2, sigma2).rvs(N2)
return R.reshape(Rshape)
DoubleGauss = pymc.stochastic_from_dist('doublegauss',
logp=doublegauss_like,
random=rdoublegauss,
dtype=np.float,
mv=True)
# set up our Stochastic variables, mu1, mu2, sigma1, sigma2, ratio
M2_mu1 = pymc.Uniform('M2_mu1', -5, 5, value=0)
M2_mu2 = pymc.Uniform('M2_mu2', -5, 5, value=1)
M2_log_sigma1 = pymc.Uniform('M2_log_sigma1', -10, 10, value=0)
M2_log_sigma2 = pymc.Uniform('M2_log_sigma2', -10, 10, value=0)
@pymc.deterministic
def M2_sigma1(M2_log_sigma1=M2_log_sigma1):
return np.exp(M2_log_sigma1)
def generate_wfpt_stochastic_class(wiener_params=None,
sampling_method='cdf',
cdf_range=(-5, 5),
sampling_dt=1e-4):
"""
create a wfpt stochastic class by creating a pymc nodes and then adding quantile functions.
Input:
wiener_params <dict> - dictonary of wiener_params for wfpt likelihoods
sampling_method <string> - an argument used by hddm.generate.gen_rts
cdf_range <sequance> - an argument used by hddm.generate.gen_rts
sampling_dt <float> - an argument used by hddm.generate.gen_rts
Ouput:
wfpt <class> - the wfpt stochastic
"""
#set wiener_params
if wiener_params is None:
wiener_params = {
'err': 1e-4,
'n_st': 2,
'n_sz': 2,
'use_adaptive': 1,
'simps_err': 1e-3,
'w_outlier': 0.1
}
wp = wiener_params
#create likelihood function
def wfpt_like(x, v, sv, a, z, sz, t, st, p_outlier=0):
return hddm.wfpt.wiener_like(x,
v,
sv,
a,
z,
sz,
t,
st,
p_outlier=p_outlier,
**wp)
#create random function
def random(v, sv, a, z, sz, t, st, p_outlier, size=None):
param_dict = {
'v': v,
'z': z,
't': t,
'a': a,
'sz': sz,
'sv': sv,
'st': st
}
return hddm.generate.gen_rts(method=sampling_method,
size=size,
dt=sampling_dt,
range_=cdf_range,
structured=False,
**param_dict)
#create pdf function
def pdf(self, x):
out = hddm.wfpt.pdf_array(x, **self.parents)
return out
#create cdf function
def cdf(self, x):
return hddm.cdfdif.dmat_cdf_array(x,
w_outlier=wp['w_outlier'],
**self.parents)
#create wfpt class
wfpt = pm.stochastic_from_dist('wfpt', wfpt_like, random=random)
#add pdf and cdf_vec to the class
wfpt.pdf = pdf
wfpt.cdf_vec = lambda self: hddm.wfpt.gen_cdf_using_pdf(
time=cdf_range[1], **dict(self.parents.items() + wp.items()))
wfpt.cdf = cdf
#add quantiles functions
add_quantiles_functions_to_pymc_class(wfpt)
return wfpt
def stochastic_from_dist(*args, **kwargs):
return pm.stochastic_from_dist(*args, dtype=np.dtype("O"), mv=True, **kwargs)
q_lb[-1] = 0
q_ub[0] = 0
q_ub[-1] = np.inf
# calucate histogram on data
n_lb = np.histogram(value, bins=q_lb)[0]
n_ub = np.histogram(value, bins=q_ub)[0]
# calculate log-likelihood
logp = np.sum(n_lb * np.log(p_lb)) + np.sum(n_ub * np.log(p_ub))
if logp == 0:
print locals()
return logp
WfptSimLikelihood = pm.stochastic_from_dist(name="Wfpt simulated multinomial likelihood based on quantiles",
logp=multinomial_like,
dtype=np.float,
mv=False)
import hddm
class HDDMSim(hddm.HDDM):
def get_bottom_node(self, param, params):
"""Create and return the wiener likelihood distribution
supplied in 'param'.
'params' is a dictionary of all parameters on which the data
depends on (i.e. condition and subject).
"""
if param.name == 'wfpt':
return WfptSimLikelihood(param.full_name,
log_sigma = pymc.Uniform('log_sigma', -5, 5, value=0)
@pymc.deterministic
def sigma(log_sigma=log_sigma):
return np.exp(log_sigma)
def sigbg_like(x, A, x0, sigma):
"""signal + background likelihood"""
return np.sum(np.log(A * np.exp(-0.5 * ((x - x0) / sigma) ** 2)
/ np.sqrt(2 * np.pi) / sigma
+ (1 - A) / W_true))
SigBG = pymc.stochastic_from_dist('sigbg',
logp=sigbg_like,
dtype=np.float, mv=True)
M = SigBG('M', A, x0, sigma, observed=True, value=x)
model = dict(M=M, A=A, x0=x0, log_sigma=log_sigma, sigma=sigma)
#----------------------------------------------------------------------
# Run the MCMC sampling
S = pymc.MCMC(model)
S.sample(iter=25000, burn=5000)
#------------------------------------------------------------
# Plot the results
fig = plt.figure(figsize=(5, 5))
ax_list = plot_mcmc([S.trace(s)[:] for s in ['A', 'x0', 'sigma']],
return np.exp(log_omega)
@pymc.deterministic
def rate(r0=r0, a=a, omega=omega, phi=phi):
return rate_func(t, r0, a, omega, phi)
def arrival_like(obs, rate, Dt):
"""likelihood for arrival time"""
N = np.sum(obs)
return (N * np.log(Dt) - np.sum(rate) * Dt + np.sum(np.log(rate[obs > 0])))
Arrival = pymc.stochastic_from_dist('arrival',
logp=arrival_like,
dtype=np.float,
mv=True)
obs_dist = Arrival('obs_dist', rate=rate, Dt=Dt, observed=True, value=obs)
model = dict(obs_dist=obs_dist,
r0=r0,
a=a,
phi=phi,
log_omega=log_omega,
omega=omega,
rate=rate)
#------------------------------------------------------------
# Compute results (and save to a pickle file)
M.step_method_dict[b][0].adaptive_scale_factor=.1
def ftb_wrap(x,n,p):
"Wrapper for Fortran fast, threaded binomial"
# if len(x) > 10000:
# cmin = [0,int(len(x)/2)]
# cmax = [cmin[1]+1,len(x)]
# lp = np.empty(2, order='F')
# pm.map_noreturn(utils.ftb, [(lp,x,n,p,i,cmin[i],cmax[i]) for i in [0,1]])
# return lp.sum()
# else:
cmin,cmax = 0,len(x)
lp = np.empty(1,order='F')
utils.ftb(lp,x,n,p,0,cmin,cmax)
return lp[0]
FTB = pm.stochastic_from_dist('ftb', ftb_wrap, random=None, dtype='int', mv=False)
def add_data(M2):
M2.data = FTB('data',
n=np.hstack((M2.n_pos, M2.n_neg)),
p=M2.p_eval_wheredata*M2.p_find,
value=np.hstack((M2.found[M2.wherefound], np.zeros(M2.n_notfound))),
observed=True, trace=False)
M2.observed_stochastics.add(M2.data)
M2.variables.add(M2.data)
M2.nodes.add(M2.data)
def restore_species_MCMC(session, dbpath):
# Load the database from the disk
db = pm.database.hdf5.load(dbpath)
return obj
######################
# END OF COPIED CODE #
######################
def centered_half_cauchy_rand(S, size):
"""sample from a half Cauchy distribution with scale S"""
return abs(S * np.tan(np.pi * pm.random_number(size) - np.pi / 2.0))
def centered_half_cauchy_logp(x, S):
"""logp of half Cauchy with scale S"""
x = np.atleast_1d(x)
if sum(x < 0):
return -np.inf
return pm.flib.cauchy(x, 0, S) + len(x) * np.log(2)
HalfCauchy = pm.stochastic_from_dist(
name="Half Cauchy", random=centered_half_cauchy_rand, logp=centered_half_cauchy_logp, dtype=np.double
)
if __name__ == "__main__":
import doctest
doctest.testmod()
np.linalg.det(cov))
true_sum = np.array(
(data.mean(), data.std())) #, np.sum(data), data.var()))
sum_stats = np.empty((samples, 2))
for sample in range(samples):
s = np.random.randn(dataset_samples) * std + mu
sum_stats[sample, :] = s.mean(), s.std() #, np.sum(s), s.var()
mean = np.mean(sum_stats, axis=0)
cov = np.cov(sum_stats.T)
# Evaluate synth likelihood
logp = mv_normal_like(true_sum, mean, cov)
return -logp
synth = pm.stochastic_from_dist(name="Wiener synthetic likelihood",
logp=synth_likelihood,
dtype=np.float32,
mv=False)
mu = pm.Uniform('mu', lower=-5, upper=5, value=0)
std = pm.Uniform('std', lower=.1, upper=2, value=1)
sl = synth('Synthetic likelihood',
value=samples,
mu=mu,
std=std,
observed=True)
#rl = pm.Normal('Regular likelihood', value=samples, mu=mu, tau=std**-2, observed=True)
def __init__(self, xi, yi, dyi, value):
self.xi, self.yi, self.dyi, self.value = xi, yi, dyi, value
@pymc.stochastic
def beta(value=np.array([0.5, 1.0])):
"""Slope and intercept parameters for a straight line.
The likelihood corresponds to the prior probability of the parameters."""
slope, intercept = value
prob_intercept = 1 + 0 * intercept
# uniform prior on theta = arctan(slope)
# d[arctan(x)]/dx = 1 / (1 + x^2)
prob_slope = np.log(1. / (1. + slope ** 2))
return prob_intercept + prob_slope
@pymc.deterministic
def model(xi=xi, beta=beta):
slope, intercept = beta
return slope * xi + intercept
# uniform prior on Pb, the fraction of bad points
Pb = pymc.Uniform('Pb', 0, 1.0, value=0.1)
# uniform prior on Yb, the centroid of the outlier distribution
Yb = pymc.Uniform('Yb', -10000, 10000, value=0)
# uniform prior on log(sigmab), the spread of the outlier distribution
log_sigmab = pymc.Uniform('log_sigmab', -10, 10, value=5)
# qi is bernoulli distributed
# Note: this syntax requires pymc version 2.2
qi = pymc.Bernoulli('qi', p=1 - Pb, value=np.ones(len(xi)))
@pymc.deterministic
def sigmab(log_sigmab=log_sigmab):
return np.exp(log_sigmab)
def outlier_likelihood(yi, mu, dyi, qi, Yb, sigmab):
"""likelihood for full outlier posterior"""
Vi = dyi ** 2
Vb = sigmab ** 2
root2pi = np.sqrt(2 * np.pi)
logL_in = -0.5 * np.sum(
qi * (np.log(2 * np.pi * Vi) + (yi - mu) ** 2 / Vi))
logL_out = -0.5 * np.sum(
(1 - qi) * (np.log(2 * np.pi * (Vi + Vb)) +
(yi - Yb) ** 2 / (Vi + Vb)))
return logL_out + logL_in
OutlierNormal = pymc.stochastic_from_dist(
'outliernormal', logp=outlier_likelihood, dtype=np.float,
mv=True)
y_outlier = OutlierNormal(
'y_outlier', mu=model, dyi=dyi, Yb=Yb, sigmab=sigmab, qi=qi,
observed=True, value=yi)
self.M = dict(y_outlier=y_outlier, beta=beta, model=model,
qi=qi, Pb=Pb, Yb=Yb, log_sigmab=log_sigmab,
sigmab=sigmab)
self.sample_invoked = False
lower : float
Lower limit
upper : float
Upper limit
"""
if np.any(x < lower) or np.any(x > upper):
return -np.Inf
else:
return -4.0*np.sum(np.log(x))
def random_oneOverXFourth(lower, upper, size):
lowerMinThird=np.power(lower,-3.0)
upperMinThird=np.power(upper,-3.0)
return np.power(lowerMinThird-np.random.random_sample(size)*(lowerMinThird-upperMinThird),-1.0/3.0)
OneOverXFourth=stochastic_from_dist('OneOverXFourth', oneOverXFourth_like, random_oneOverXFourth, dtype=np.float)
def oneOverXSecond_like(x, lower, upper):
R"""
Log-likelihood for stochastic variable with 1/x^2 distribution
.. math::
f(x \mid lower, upper) = \frac{x^{-2}}{lower^{-1}-upper^{-1}}
:Parameters
x : float
:math`lower \leq x \leq upper`
lower : float
Lower limit
upper : float
Upper limit
from collections import OrderedDict
def cython_Go(value, imu_go, isigma_go, itau_go):
"""Ex-Gaussian log-likelihood of GoRTs"""
return stop_likelihoods.Go(value, imu_go, isigma_go, itau_go)
def cython_SRRT(value, issd, imu_go, isigma_go, itau_go, imu_stop, isigma_stop, itau_stop):
"""Censored ExGaussian log-likelihood of SRRTs"""
return stop_likelihoods.SRRT(value, issd, imu_go, isigma_go, itau_go, imu_stop, isigma_stop, itau_stop)
def cython_Inhibitions(value, imu_go, isigma_go, itau_go, imu_stop, isigma_stop, itau_stop):
"""Censored ExGaussian log-likelihood of inhibitions"""
return stop_likelihoods.Inhibitions(value, imu_go, isigma_go, itau_go, imu_stop, isigma_stop, itau_stop)
Go_like = pm.stochastic_from_dist(name="Ex-Gauss GoRT",
logp=cython_Go,
dtype=np.float,
mv=False)
SRRT_like = pm.stochastic_from_dist(name="CensoredEx-Gauss SRRT",
logp=cython_SRRT,
dtype=np.float,
mv=False)
Inhibitions_like = pm.stochastic_from_dist(name="CensoredEx-Gauss Inhibittions",
logp=cython_Inhibitions,
dtype=np.int32,
mv=False)
class KnodeGo(Knode):
def create_node(self, node_name, kwargs, data):
new_data = data[data['ss_presented'] == 0]
kwargs['value'] = new_data['rt']
#Likelihood Function#
#####################
def outlier_likelihood(yi, mu, Yb, dyi, qi,sigmab,int_scat):
"""likelihood for full outlier posterior"""
Vi = dyi**2
Vb = sigmab ** 2
logL_in = -0.5 * np.sum(qi * (np.log(2 * np.pi * (Vi+int_scat**2)) + (yi - mu) ** 2 / (Vi+int_scat**2)))
logL_out = -0.5 * np.sum((1 - qi) * (np.log(2 * np.pi * (Vi + Vb)) + (yi - Yb) ** 2 / (Vi + Vb)))
return logL_out + logL_in
############
#PyMC stuff#
############
OutlierNormal = pm.stochastic_from_dist('outliernormal',logp=outlier_likelihood,dtype=np.float,mv=True)
y_outlier = OutlierNormal('y_outlier', mu=lgM200, dyi=precy_std, Yb=Yb,sigmab=sigmab, qi=qi,int_scat=intrscat_std, observed=True, value=lgy)
mcmc = pm.MCMC([alpha,beta,n200,lgn200,nbkg,obsbkg,obstot,lgM200,y_outlier,obs_var_lgm200,precy_std,log_sigmab,sigmab,Yb,qi,intrscat_std,scat_alpha,scat_beta])
mcmc.sample(iter=200000, burn=100000)
pymc_trace = [mcmc.trace('alpha')[:],
mcmc.trace('beta')[:],
1.0/mcmc.trace('intrscat_std')[:]**2]
plot_MCMC_results(np.log(rich), lgy, pymc_trace)
plt.show()
plt.plot(np.log(rich), lgy,'ko')
plt.errorbar(np.log(rich), lgy,xerr=0.434/np.sqrt(rich),yerr=np.median(mcmc.trace('precy_std')[:],0),fmt='None',ecolor='darkgrey')
xgrid = np.arange(0.0,5.0,0.01)
model_values = np.median(pymc_trace[0]) + 14.5 + np.median(pymc_trace[1])*(xgrid - 1.5)
Vi = dyi**2
Vb = sigmab**2
root2pi = np.sqrt(2 * np.pi)
L_in = (1. / root2pi / dyi * np.exp(-0.5 * (yi - model)**2 / Vi))
L_out = (1. / root2pi / np.sqrt(Vi + Vb) * np.exp(-0.5 * (yi - Yb)**2 /
(Vi + Vb)))
return np.sum(np.log((1 - Pb) * L_in + Pb * L_out))
MixtureNormal = pymc.stochastic_from_dist('mixturenormal',
logp=mixture_likelihood,
dtype=np.float,
mv=True)
y_mixture = MixtureNormal('y_mixture',
model=model_M1,
dyi=dyi,
Pb=Pb,
Yb=Yb,
sigmab=sigmab,
observed=True,
value=yi)
M1 = dict(y_mixture=y_mixture,
beta_M1=beta_M1,
model_M1=model_M1,
Pb=Pb,
def bivariate_poisson_like(values, l_1, l_2, l_3):
return biv_pois.bivariate_poisson_like(values[0], values[1], l_1, l_2, l_3)
def rbivariate_poisson(l_1, l_2, l_3):
l_1 = max(l_1, eps)
l_2 = max(l_2, eps)
l_3 = max(l_3, eps)
x = pymc.rpoisson(l_3)
return [pymc.rpoisson(l_1) + x, pymc.rpoisson(l_2) + x]
BivariatePoisson = pymc.stochastic_from_dist('BivariatePoisson',
logp=bivariate_poisson_like,
random=rbivariate_poisson,
dtype=np.int,
mv=True)
bracket = pd.read_csv("TourneySlots.csv")
mm_teams = pd.read_csv("TourneySeeds.csv")
seeds = dict(
zip(mm_teams[mm_teams['Season'] == 2016]['Seed'],
mm_teams[mm_teams['Season'] == 2016]['Team']))
mm_teams = mm_teams[mm_teams['Season'] == 2016]['Team'].unique()
teams = mm_teams #list(set(np.hstack((observed_matches['lteam'].unique() , observed_matches['wteam'].unique()))))
N = len(teams)
team_to_ind = dict(zip(teams, range(N)))
attack_strength = np.empty(N, dtype=object)
def pymc_linear_fit_mixture(data1, data2, data1err=None, data2err=None,
print_results=False, intercept=True, nsample=5000, burn=1000,
thin=10, return_MC=False, guess=None, verbose=0):
"""
***NOT TESTED*** ***MAY IGNORE X ERRORS***
Use pymc to fit a line to data with outliers assuming outliers
come from a broad, uniform distribution that cover all the data
The model doesn't work exactly right; it over-rejects "outliers" because
'bady' is an unobserved stochastic parameter that can therefore move.
Maybe it should be implemented as a "potential" or a mixture model, e.g.
as in Hogg 2010 / Van Der Plas' astroml example:
http://astroml.github.com/book_figures/chapter8/fig_outlier_rejection.html
"""
import pymc
if guess is None:
guess = (0,0)
xmu = pymc.distributions.Uninformative(name='x_observed',value=0)
if data1err is None:
xdata = pymc.distributions.Normal('x', mu=xmu, observed=True,
value=data1, tau=1, trace=False)
else:
xtau = pymc.distributions.Uninformative(name='x_tau',
value=1.0/data1err**2, observed=True, trace=False)
xdata = pymc.distributions.Normal('x', mu=xmu, observed=True,
value=data1, tau=xtau, trace=False)
d={'slope':pymc.distributions.Uninformative(name='slope', value=guess[0]),
#d['badvals'] = pymc.distributions.Binomial('bad',len(data2),0.5,value=[False]*len(data2))
#d['badx'] = pymc.distributions.Uniform('badx',min(data1-data1err),max(data1+data1err),value=data1)
#'badvals':pymc.distributions.DiscreteUniform('bad',0,1,value=[False]*len(data2)),
#'bady':pymc.distributions.Uniform('bady',min(data2-data2err),max(data2+data2err),value=data2),
}
# set up "mixture model" from Hogg et al 2010:
# uniform prior on Pb, the fraction of bad points
Pb = pymc.Uniform('Pb', 0, 1.0, value=0.1)
# uniform prior on Yb, the centroid of the outlier distribution
Yb = pymc.Uniform('Yb', -10000, 10000, value=0)
# uniform prior on log(sigmab), the spread of the outlier distribution
log_sigmab = pymc.Uniform('log_sigmab', -10, 10, value=5)
@pymc.deterministic
def sigmab(log_sigmab=log_sigmab):
return np.exp(log_sigmab)
MixtureNormal = pymc.stochastic_from_dist('mixturenormal',
logp=mixture_likelihood,
dtype=np.float,
mv=True)
if intercept:
d['intercept'] = pymc.distributions.Uninformative(name='intercept',
value=guess[1])
@pymc.deterministic(trace=False)
def model(x=xdata,slope=d['slope'],intercept=d['intercept']):
return (x*slope+intercept)
else:
@pymc.deterministic(trace=False)
def model(x=xdata,slope=d['slope']):
return x*slope
d['f'] = model
dyi = data2err if data2err is not None else np.ones(data2.shape)
y_mixture = MixtureNormal('y_mixture', model=model, dyi=dyi,
Pb=Pb, Yb=Yb, sigmab=sigmab,
observed=True, value=data2)
d['y'] = y_mixture
#if data2err is None:
# ydata = pymc.distributions.Normal('y', mu=model, observed=True,
# value=data2, tau=1, trace=False)
#else:
# ytau = pymc.distributions.Uninformative(name='y_tau',
# value=1.0/data2err**2, observed=True, trace=False)
# ydata = pymc.distributions.Normal('y', mu=model, observed=True,
# value=data2, tau=ytau, trace=False)
#d['y'] = ydata
MC = pymc.MCMC(d)
MC.sample(nsample,burn=burn,thin=thin,verbose=verbose)
"""Equation 17 of Hogg 2010"""
Vi = dyi ** 2
Vb = sigmab ** 2
root2pi = np.sqrt(2 * np.pi)
L_in = (1. / root2pi / dyi
* np.exp(-0.5 * (yi - model) ** 2 / Vi))
L_out = (1. / root2pi / np.sqrt(Vi + Vb)
* np.exp(-0.5 * (yi - Yb) ** 2 / (Vi + Vb)))
return np.sum(np.log((1 - Pb) * L_in + Pb * L_out))
MixtureNormal = pymc.stochastic_from_dist('mixturenormal',
logp=mixture_likelihood,
dtype=np.float,
mv=True)
y_mixture = MixtureNormal('y_mixture', model=model_M1, dyi=dyi,
Pb=Pb, Yb=Yb, sigmab=sigmab,
observed=True, value=yi)
M1 = dict(y_mixture=y_mixture, beta_M1=beta_M1, model_M1=model_M1,
Pb=Pb, Yb=Yb, log_sigmab=log_sigmab, sigmab=sigmab)
#----------------------------------------------------------------------
# Third model: marginalizes over the probability that each point is an outlier.
# define priors on beta = (slope, intercept)
@pymc.stochastic
def beta_M2(value=np.array([2., 100.])):
Rshape = R.shape
R = np.atleast1d(R)
mask1 = (R < r1)
mask2 = ~mask1
N1 = mask1.sum()
N2 = R.size - N1
R[mask1] = norm(mu1, sigma1).rvs(N1)
R[mask2] = norm(mu2, sigma2).rvs(N2)
return R.reshape(Rshape)
DoubleGauss = pymc.stochastic_from_dist('doublegauss',
logp=doublegauss_like,
random=rdoublegauss,
dtype=np.float,
mv=True)
# set up our Stochastic variables, mu1, mu2, sigma1, sigma2, ratio
M2_mu1 = pymc.Uniform('M2_mu1', -5, 5, value=0)
M2_mu2 = pymc.Uniform('M2_mu2', -5, 5, value=1)
M2_log_sigma1 = pymc.Uniform('M2_log_sigma1', -10, 10, value=0)
M2_log_sigma2 = pymc.Uniform('M2_log_sigma2', -10, 10, value=0)
@pymc.deterministic
def M2_sigma1(M2_log_sigma1=M2_log_sigma1):
return np.exp(M2_log_sigma1)
q_ub[-1] = np.inf
# calucate histogram on data
n_lb = np.histogram(value, bins=q_lb)[0]
n_ub = np.histogram(value, bins=q_ub)[0]
# calculate log-likelihood
logp = np.sum(n_lb * np.log(p_lb)) + np.sum(n_ub * np.log(p_ub))
if logp == 0:
print locals()
return logp
WfptSimLikelihood = pm.stochastic_from_dist(
name="Wfpt simulated multinomial likelihood based on quantiles",
logp=multinomial_like,
dtype=np.float,
mv=False)
import hddm
class HDDMSim(hddm.HDDM):
def get_bottom_node(self, param, params):
"""Create and return the wiener likelihood distribution
supplied in 'param'.
'params' is a dictionary of all parameters on which the data
depends on (i.e. condition and subject).
"""
@pymc.deterministic
def error(log_error=log_error):
return np.exp(log_error)
def gaussgauss_like(x, mu, sigma, error):
"""likelihood of gaussian with gaussian errors"""
sig2 = sigma**2 + error**2
x_mu2 = (x - mu)**2
return -0.5 * np.sum(np.log(sig2) + x_mu2 / sig2)
GaussGauss = pymc.stochastic_from_dist('gaussgauss',
logp=gaussgauss_like,
dtype=np.float,
mv=True)
M = GaussGauss('M', mu, sigma, error, observed=True, value=xi)
model = dict(mu=mu,
log_sigma=log_sigma,
sigma=sigma,
log_error=log_error,
error=error,
M=M)
#------------------------------------------------------------
# perform the MCMC sampling
np.random.seed(0)
S = pymc.MCMC(model)
S.sample(iter=25000, burn=2000)
import hddm
def wiener_like_contaminant(value, cont_x, v, sv, a, z, sz, t, st, t_min,
t_max, err, n_st, n_sz, use_adaptive, simps_err):
"""Log-likelihood for the simple DDM including contaminants"""
return hddm.wfpt.wiener_like_contaminant(value, cont_x.astype(np.int32), v,
sv, a, z, sz, t, st, t_min, t_max,
err, n_st, n_sz, use_adaptive,
simps_err)
WienerContaminant = pm.stochastic_from_dist(
name="Wiener Simple Diffusion Process",
logp=wiener_like_contaminant,
dtype=np.float,
mv=True)
def general_WienerCont(err=1e-4,
n_st=2,
n_sz=2,
use_adaptive=1,
simps_err=1e-3):
_like = lambda value, cont_x, v, sv, a, z, sz, t, st, t_min, t_max, err=err, n_st=n_st, n_sz=n_sz, \
use_adaptive=use_adaptive, simps_err=simps_err: \
wiener_like_contaminant(value, cont_x, v, sv, a, z, sz, t, st, t_min, t_max,\
err=err, n_st=n_st, n_sz=n_sz, use_adaptive=use_adaptive, simps_err=simps_err)
_like.__doc__ = wiener_like_contaminant.__doc__
return pm.stochastic_from_dist(name="Wiener Diffusion Contaminant Process",
def stochastic_from_dist(*args, **kwargs):
return pm.stochastic_from_dist(*args, dtype=np.dtype('O'),
mv=True, **kwargs)
from kabuki import Parameter
from kabuki.distributions import scipy_stochastic
import numpy as np
from scipy import stats
try:
import wfpt_switch
except:
pass
def wiener_like_multi(value, v, V, a, z, Z, t, T, multi=None):
"""Log-likelihood for the simple DDM"""
return hddm.wfpt.wiener_like_multi(value, v, V, a, z, Z, t, T, .001, multi=multi)
WienerMulti = pm.stochastic_from_dist(name="Wiener Simple Diffusion Process",
logp=wiener_like_multi,
dtype=np.float)
class wfpt_switch_gen(stats.distributions.rv_continuous):
err = 1e-4
evals = 100
def _argcheck(self, *args):
return True
def _logp(self, x, v, v_switch, V_switch, a, z, t, t_switch, T):
"""Log-likelihood for the simple DDM switch model"""
# if t < T/2 or t_switch < T/2 or t<0 or t_switch<0 or T<0 or a<=0 or z<=0 or z>=1 or T>.5:
# print "Condition not met"
logp = wfpt_switch.wiener_like_antisaccade_precomp(x, v, v_switch, V_switch, a, z, t, t_switch, T, self.err, evals=self.evals)
return logp
