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 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
"""
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
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])
