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,
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.])):
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