def test_check_discrete_minibatch(): disaster_data_t = tt.vector() disaster_data_t.tag.test_value = np.zeros(len(disaster_data)) with Model() as disaster_model: switchpoint = DiscreteUniform( 'switchpoint', lower=year.min(), upper=year.max(), testval=1900) # Priors for pre- and post-switch rates number of disasters early_rate = Exponential('early_rate', 1) late_rate = Exponential('late_rate', 1) # Allocate appropriate Poisson rates to years before and after current rate = switch(switchpoint >= year, early_rate, late_rate) disasters = Poisson('disasters', rate, observed=disaster_data_t) def create_minibatch(): while True: return disaster_data # This should raise ValueError assert_raises( ValueError, advi_minibatch, model=disaster_model, n=10, minibatch_RVs=[disasters], minibatch_tensors=[disaster_data_t], minibatches=[create_minibatch()], verbose=False)
def test_check_discrete_minibatch(): disaster_data_t = tt.vector() disaster_data_t.tag.test_value = np.zeros(len(disaster_data)) with Model() as disaster_model: switchpoint = DiscreteUniform('switchpoint', lower=year.min(), upper=year.max(), testval=1900) # Priors for pre- and post-switch rates number of disasters early_rate = Exponential('early_rate', 1) late_rate = Exponential('late_rate', 1) # Allocate appropriate Poisson rates to years before and after current rate = switch(switchpoint >= year, early_rate, late_rate) disasters = Poisson('disasters', rate, observed=disaster_data_t) def create_minibatch(): while True: return (disaster_data, ) # This should raise ValueError assert_raises(ValueError, advi_minibatch, model=disaster_model, n=10, minibatch_RVs=[disasters], minibatch_tensors=[disaster_data_t], minibatches=create_minibatch(), verbose=False)
def build_disaster_model(masked=False): disasters_data = np.array([4, 5, 4, 0, 1, 4, 3, 4, 0, 6, 3, 3, 4, 0, 2, 6, 3, 3, 5, 4, 5, 3, 1, 4, 4, 1, 5, 5, 3, 4, 2, 5, 2, 2, 3, 4, 2, 1, 3, 2, 2, 1, 1, 1, 1, 3, 0, 0, 1, 0, 1, 1, 0, 0, 3, 1, 0, 3, 2, 2, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 2, 1, 0, 0, 0, 1, 1, 0, 2, 3, 3, 1, 1, 2, 1, 1, 1, 1, 2, 4, 2, 0, 0, 1, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1]) if masked: disasters_data[[23, 68]] = -1 disasters_data = np.ma.masked_values(disasters_data, value=-1) years = len(disasters_data) with pm.Model() as model: # Prior for distribution of switchpoint location switchpoint = pm.DiscreteUniform('switchpoint', lower=0, upper=years) # Priors for pre- and post-switch mean number of disasters early_mean = pm.Exponential('early_mean', lam=1.) late_mean = pm.Exponential('late_mean', lam=1.) # Allocate appropriate Poisson rates to years before and after current # switchpoint location idx = np.arange(years) rate = pm.switch(switchpoint >= idx, early_mean, late_mean) # Data likelihood pm.Poisson('disasters', rate, observed=disasters_data) return model
def test_check_discrete(): with Model() as disaster_model: switchpoint = DiscreteUniform('switchpoint', lower=year.min(), upper=year.max(), testval=1900) # Priors for pre- and post-switch rates number of disasters early_rate = Exponential('early_rate', 1) late_rate = Exponential('late_rate', 1) # Allocate appropriate Poisson rates to years before and after current rate = switch(switchpoint >= year, early_rate, late_rate) disasters = Poisson('disasters', rate, observed=disaster_data) # This should raise ValueError assert_raises(ValueError, advi, model=disaster_model, n=10)
def createSignalModelExponential(data): """ Toy model that treats the first ~10% of the waveform as an exponential. Does a good job of finding the start time (t_0) Since I made this as a toy, its super brittle. Waveform must be normalized """ with Model() as signal_model: switchpoint = Uniform('switchpoint', lower=0, upper=len(data), testval=len(data)/2) noise_sigma = HalfNormal('noise_sigma', sd=1.) #Modeling these parameters this way is why wf needs to be normalized exp_rate = Uniform('exp_rate', lower=0, upper=.5, testval = 0.05) exp_scale = Uniform('exp_scale', lower=0, upper=.5, testval = 0.1) timestamp = np.arange(0, len(data), dtype=np.float) rate = switch(switchpoint >= timestamp, 0, exp_rate) baseline_model = Deterministic('baseline_model', exp_scale * (exp( (timestamp-switchpoint)*rate)-1.) ) baseline_observed = Normal("baseline_observed", mu=baseline_model, sd=noise_sigma, observed= data ) return signal_model
# THE DATA. N = 30 z = 8 y = np.repeat([1, 0], [z, N - z]) # THE MODEL. with pm.Model() as model: # Hyperprior on model index: model_index = pm.DiscreteUniform('model_index', lower=0, upper=1) # Prior nu = pm.Normal('nu', mu=0, tau=0.1) # it is posible to use tau or sd eta = pm.Gamma('eta', .1, .1) theta0 = 1 / (1 + pm.exp(-nu)) # theta from model index 0 theta1 = pm.exp(-eta) # theta from model index 1 theta = pm.switch(pm.eq(model_index, 0), theta0, theta1) # Likelihood y = pm.Bernoulli('y', p=theta, observed=y) # Sampling start = pm.find_MAP() step1 = pm.Metropolis(model.vars[1:]) step2 = pm.ElemwiseCategoricalStep(var=model_index, values=[0, 1]) trace = pm.sample(10000, [step1, step2], start=start, progressbar=False) # EXAMINE THE RESULTS. burnin = 1000 thin = 5 ## Print summary for each trace #pm.summary(trace[burnin::thin]) #pm.summary(trace)
# Hyperprior on mu and kappa: kappa = pm.Gamma('kappa', shape_Gamma, rate_Gamma, shape=n_cond) mu0 = pm.Beta('mu0', 1, 1) a_Beta0 = mu0 * kappa[cond_of_subj] b_Beta0 = (1 - mu0) * kappa[cond_of_subj] mu1 = pm.Beta('mu1', 1, 1, shape=n_cond) a_Beta1 = mu1[cond_of_subj] * kappa[cond_of_subj] b_Beta1 = (1 - mu1[cond_of_subj]) * kappa[cond_of_subj] #Prior on theta theta0 = pm.Beta('theta0', a_Beta0, b_Beta0, shape=n_subj) theta1 = pm.Beta('theta1', a_Beta1, b_Beta1, shape=n_subj) # if model_index == 0 then sample from theta1 else sample from theta0 theta = pm.switch(pm.eq(model_index, 0), theta1, theta0) # Likelihood: y = pm.Binomial('y', p=theta, n=n_trl_of_subj, observed=n_corr_of_subj) # Sampling start = pm.find_MAP() step1 = pm.Metropolis(model.vars[1:]) step2 = pm.ElemwiseCategoricalStep(var=model_index,values=[0,1]) trace = pm.sample(20000, [step1, step2], start=start, progressbar=False) # EXAMINE THE RESULTS. burnin = 10000 thin = 10
# This gives apple observation as bernoulli variable pApple = pm.Uniform('pApple', lower = 0.0, upper = 1.0) apple_obs = pm.Bernoulli('apple_obs', p=pApple, observed=apple_observed) pAndroid = pm.Uniform('pAndroid', lower = 0.0, upper = 1.0) android_obs = pm.Bernoulli('android_obs', p=pAndroid, observed=android_observed) # Duration observed is a switch point between two poisson distribution switchpoint = pm.DiscreteUniform('switchpoint', lower=0, upper=len(duration_observed)) early_mean = pm.Uniform('early_mean', lower = 0.0, upper = 100.0) late_mean = pm.Uniform('late_mean', lower= 3000.0, upper = 4000.0) idx = np.arange(len(duration_observed)) rate = pm.switch(switchpoint >= idx, early_mean, late_mean) duration_sorted = np.sort(duration_observed) print "The switchpoint duration is: ", duration_sorted[49531] plt.hist(duration_sorted) plt.show() duration_obs = pm.Normal('duration', mu=rate, observed= duration_sorted) # Next is to implement A that depends on bcdef # sigmaA = pm.Uniform('sigmaA', lower=0, upper=100) # sigmaB = pm.Uniform('sigmaB', lower=0, upper=100) # # sigmaC = pm.Uniform('sigmaC', lower=0, upper=1000) # # a_observed is weekday start time # distributionA = pm.Normal('a', mu = muA, sd = sigmaA, observed = a_observed)
3, 3, 1, -999, 2, 1, 1, 1, 1, 2, 4, 2, 0, 0, 1, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1], value=-999) year = np.arange(1851, 1962) '''Model generation''' HansModel = pm.Model() with HansModel: switchpoint = pm.DiscreteUniform('switchpoint', lower=year.min(), upper=year.max(), testval=1900) # prior early_rate = pm.Exponential('early_rate',1) late_rate = pm.Exponential('late_rate',1) # Allocate rate rate = pm.switch(switchpoint >= year, early_rate, late_rate) # Likelihood disaster=pm.Poisson('disaster',mu=rate,observed=disaster_data) ''' MCMC setting ''' with HansModel: # Step1 = pm.Slice(vars=[early_rate,late_rate,switchpoint,disaster.missing_values[0]]) trace = pm.sample(1000,step=pm.NUTS()) pm.traceplot(trace) print pm.summary(trace) plt.show()
plt.ylabel("Disaster count") plt.xlabel("Year") plt.show() from pymc3 import DiscreteUniform, Poisson, switch, Model, Exponential, NUTS, Metropolis, sample, traceplot with Model() as disaster_model: switchpoint = DiscreteUniform('switchpoint', lower=year.min(), upper=year.max(), testval=1900) # Priors for pre- and post-switch rates number of disasters early_rate = Exponential('early_rate', 1) late_rate = Exponential('late_rate', 1) # Allocate appropriate Poisson rates to years before and after current rate = switch(switchpoint >= year, early_rate, late_rate) disasters = Poisson('disasters', rate, observed=disaster_data) step1 = NUTS([early_rate, late_rate]) # Use Metropolis for switchpoint, and missing values since it accommodates discrete variables step2 = Metropolis([switchpoint, disasters.missing_values[0]]) trace = sample(10000, step=[step1, step2]) traceplot(trace)
plt.tight_layout() plt.show() """ with pm.Model() as model: prior_model_prob= 0.5 tau = pm.Bernoulli('tau',prior_model_prob) mu_p = pm.Uniform('mu_p', 0, 60) alpha = pm.Exponential('alpha', lam= 0.2) mu_nb = pm.Uniform('mu_nb', lower=0, upper=60) y_like = pm.DensityDist('y_like', lambda value: pm.switch(tau, pm.Poisson.dist(mu_p).logp(value), pm.NegativeBinomial.dist(mu_nb, alpha).logp(value) ), observed=messages['time_delay_seconds'].values) start = pm.find_MAP() step1 = pm.Metropolis([mu_p, alpha, mu_nb]) step2 = pm.ElemwiseCategorical(vars=[tau], values=[0,1]) trace = pm.sample(200000, step=[step1, step2], start=start) _ = pm.traceplot(trace[burnin:], varnames=['tau']) plt.show() prob_pois = trace[burnin:]['tau'].mean() prob_nb = 1 - prob_pois BF = (prob_nb/prob_pois)*(prior_model_prob/(1-prior_model_prob)) print("Bayes Factor: %s" % BF)
""" from __future__ import division import numpy as np import pymc3 as pm import matplotlib.pyplot as plt from plot_post import plot_post ## specify the Data y = np.repeat([0, 1], [3, 6]) # 3 tails 6 heads with pm.Model() as model: # Hyperhyperprior: model_index = pm.DiscreteUniform('model_index', lower=0, upper=1) # Hyperprior: kappa_theta = 12 mu_theta = pm.switch(pm.eq(model_index, 1), 0.25, 0.75) # Prior distribution: a_theta = mu_theta * kappa_theta b_theta = (1 - mu_theta) * kappa_theta theta = pm.Beta('theta', a_theta, b_theta) # theta distributed as beta density #likelihood y = pm.Bernoulli('y', theta, observed=y) start = pm.find_MAP() step = pm.Metropolis() trace = pm.sample(10000, step, start=start, progressbar=False) ## Check the results. burnin = 2000 # posterior samples to discard thin = 1 # posterior samples to discard
def createSignalModelWithLookup(data, wfMax): """ Uses a lookup table to avoid having to call siggen. Lookup locations are along a one-dimensional line from PC to the detector corner. See generate_siggen_lookup.py wfMax: maximum of the input signal. Used as a prior for the for scaling of the simulated pulse """ with Model() as signal_model: switchpoint = DiscreteUniform('switchpoint', lower=0, upper=len(data)) noise_sigma = HalfNormal('noise_sigma', sd=1.) siggen_sigma = HalfNormal('siggen_sigma', sd=10.) timestamp = np.arange(0, len(data), dtype=np.int) uncertainty_model = switch(switchpoint >= timestamp, noise_sigma, siggen_sigma) wf_scale = Normal('wf_scale', sd=10., mu=wfMax) detRad = np.floor(35.41) detZ = np.floor(41.5) dtEstimate = DiscreteUniform('dtEstimate', lower=0, upper=99 ) # radiusEstimate = DiscreteUniform('radiusEstimate', lower=0, upper=35 ) # zEstimate = DiscreteUniform('zEstimate', lower=0, upper=41) @as_op(itypes=[T.lscalar, T.lscalar, T.dscalar], otypes=[T.dvector]) def siggen_model_dt(switchpoint, dtEstimate, wf_scale): siggen_out = dt_array[dtEstimate, :] siggen_out *= wf_scale T.clip(dtEstimate, 0, 99) #THIS IS A DISASTER. NEED to find a better way to handle this out = np.zeros(len(data)) out[switchpoint:] = siggen_out[0:(len(data) - switchpoint)] # print "length of out is %d" % len(out) return out @as_op(itypes=[T.lscalar, T.lscalar, T.lscalar], otypes=[T.dvector]) def siggen_model(switchpoint, r, z): siggen_out = findSiggenWaveform(0,r,z,np.amax(np_data)) out = np.zeros(len(data)) out[switchpoint:] = siggen_out[0:(len(data) - switchpoint)] return out # print "length of data is %d" % len(data) # @as_op(itypes=[T.lscalar, T.dscalar, T.dscalar], otypes=[T.dvector]) # # def crazy_modulo3(switchpoint, exp_scale, exp_rate): # out = np.zeros(len(data)) # out[switchpoint:] = exp_scale * (np.exp( exp_rate * (timestamp[switchpoint:] - switchpoint))-1.) # return out #baseline_model = Deterministic('baseline_model', exp_scale * (exp( (timestamp-switchpoint)*rate)-1.) ) # baseline_model = siggen_model(switchpoint, radiusEstimate, zEstimate) baseline_model_dt = siggen_model_dt(switchpoint, dtEstimate, wf_scale) baseline_observed = Normal("baseline_observed", mu=baseline_model_dt, sd=uncertainty_model, observed= data ) return signal_model #def createSignalModelDynamic(data, wfMax): # """ # Calls siggen in real time # # """ # # with Model() as signal_model: # # switchpoint = DiscreteUniform('switchpoint', lower=0, upper=len(data)) # noise_sigma = HalfNormal('noise_sigma', sd=1.) # siggen_sigma = HalfNormal('siggen_sigma', sd=10.) # # timestamp = np.arange(0, len(data), dtype=np.int) # # uncertainty_model = switch(switchpoint >= timestamp, noise_sigma, siggen_sigma) # # detRad = np.floor(35.41) # detZ = np.floor(41.5) # # dtEstimate = DiscreteUniform('dtEstimate', lower=0, upper=99 ) # # # # radiusEstimate = DiscreteUniform('radiusEstimate', lower=0, upper=35 ) # # zEstimate = DiscreteUniform('zEstimate', lower=0, upper=41) # # # # @as_op(itypes=[T.lscalar, T.lscalar], otypes=[T.dvector]) # def siggen_model_dt(switchpoint, dtEstimate): # siggen_out = dt_array[dtEstimate, :] # siggen_out *= wfMax # # T.clip(dtEstimate, 0, 99) #THIS IS A DISASTER. NEED to find a better way to handle this # # out = np.zeros(len(data)) # out[switchpoint:] = siggen_out[0:(len(data) - switchpoint)] # # # print "length of out is %d" % len(out) # return out # # @as_op(itypes=[T.lscalar, T.lscalar, T.lscalar], otypes=[T.dvector]) # def siggen_model(switchpoint, r, z): # siggen_out = findSiggenWaveform(0,r,z,np.amax(np_data)) # out = np.zeros(len(data)) # out[switchpoint:] = siggen_out[0:(len(data) - switchpoint)] # # return out # # # # print "length of data is %d" % len(data) # # # @as_op(itypes=[T.lscalar, T.dscalar, T.dscalar], otypes=[T.dvector]) # # # # def crazy_modulo3(switchpoint, exp_scale, exp_rate): # # out = np.zeros(len(data)) # # out[switchpoint:] = exp_scale * (np.exp( exp_rate * (timestamp[switchpoint:] - switchpoint))-1.) # # return out # # # #baseline_model = Deterministic('baseline_model', exp_scale * (exp( (timestamp-switchpoint)*rate)-1.) ) # # # baseline_model = siggen_model(switchpoint, radiusEstimate, zEstimate) # baseline_model_dt = siggen_model_dt(switchpoint, dtEstimate) # # # baseline_observed = Normal("baseline_observed", mu=baseline_model_dt, sd=uncertainty_model, observed= data ) # # return signal_model
cpf['trend'] = g alpha = 1.0 / cpf['w_trend'].mean() beta = 1.0 / cpf['w_trend'].std() t = np.range(0, n) with pm.Model() as my_model: switchpoint = pm.DiscreteUniform("switchpoint", lower=0, upper=cpf['t'].max(), shape=10) for i in range(n): mu_name = 'mu_' + str(i) setattr(my_model, mu_name, pm.Exponential(mu_name, alpha)) sd_name = 'sd_' + str(i) setattr(my_model, sd_name, pm.Exponential(sd_name, beta)) t = 0 for i in range(n): mu = pm.switch(switchpoint >= t, mu_1, mu_2 ) var = pm.switch(switchpoint >= t, sd_1, sd_2 ) obs = pm.Normal('x',mu=mu,sd=sd,observed=data) with model: step1 = pm.NUTS( [mu_1, mu_2, sd_1, sd_2] ) step2 = pm.Metropolis( [switchpoint] ) trace = pm.sample( 10000, step=[step1,step2] ) traceplot(trace,varnames=['switchpoint','mu_1','mu_2', 'sd_1', 'sd_2']) plt.show() n = len(cpf) with pm.Model(): theta = pm.Beta('theta', 0.5, 0.5, shape=n) mu = pm.Bernoulli('mu', theta, shape=n)
# FIXME: Allow each station can have nonzero mean. Check it for both parts. Use # hierarchical model. with pymc3.Model() as model: # Prior for dof nu = pymc3.Exponential('nu', 0.1) # Prior for distribution of switchpoint location switchpoint = pymc3.DiscreteUniform('switchpoint', lower=0, upper=max(df['timedelta'])) # Priors for pre- and post-switch std early_std = pymc3.Exponential('early_std', lam=1.) late_std = pymc3.Exponential('late_std', lam=1.) # Allocate appropriate gaussian std to years before and after current # switchpoint location idx = np.arange(len(df['timedelta'])) std = pymc3.switch(switchpoint >= idx, early_std, late_std) # Data likelihood total_rates = pymc3.T('total_rates', nu=nu, mu=0., lam=std, observed=3. * 10 ** 10 * df['total_rate']) with model: # Initial values for stochastic nodes start = {'early_std': 3., 'late_std': 0.5, 'nu': 3} # Use slice sampler for means step1 = pymc3.Slice([nu, early_std, late_std]) # Use Metropolis for switchpoint, since it accomodates discrete variables step2 = pymc3.Metropolis([switchpoint]) tr = pymc3.sample(10000, tune=500, start=start, step=[step1, step2])