def main():
#load data
returns = data.get_data_google('SPY', start='2008-5-1', end='2009-12-1')['Close'].pct_change()
returns.plot()
plt.ylabel('daily returns in %');
with pm.Model() as sp500_model:
nu = pm.Exponential('nu', 1./10, testval=5.0)
sigma = pm.Exponential('sigma', 1./0.02, testval=0.1)
s = pm.GaussianRandomWalk('s', sigma**-2, shape=len(returns))
r = pm.StudentT('r', nu, lam=pm.math.exp(-2*s), observed=returns)
with sp500_model:
trace = pm.sample(2000)
pm.traceplot(trace, [nu, sigma]);
plt.show()
plt.figure()
returns.plot()
plt.plot(returns.index, np.exp(trace['s',::5].T), 'r', alpha=.03)
plt.legend(['S&P500', 'stochastic volatility process'])
plt.show()
def run( n=100000 ):
with model:
# initialize NUTS() with ADVI under the hood
trace = pm.sample( n )
# drop some first samples as burnin
pm.traceplot( trace[1000:] )
def run(n = 3000):
if n == "short":
n = 50
with model:
trace = pm.sample(n, step, start)
pm.traceplot(trace);
def run(n=1000):
if n == "short":
n = 50
with model:
trace = pm.sample(n)
pm.traceplot(trace, varnames=['mu', 'r'],
lines={'mu': mu_r, 'r': corr_r[np.triu_indices(n_var, k=1)]})
def run(n=2000):
model = build_model()
with model:
# initialize NUTS() with ADVI under the hood
trace = pm.sample(n, nuts_kwargs={'target_accept':.99})
# drop some first samples as burnin
pm.traceplot(trace[1000:])
def run(n=3000):
if n == "short":
n = 500
with model:
trace = pm.sample(n, step)
burn = n/10
pm.traceplot(trace[burn:]);
pm.plots.summary(trace[burn:])
def run(n=1000):
if n == "short":
n = 50
with arma_model:
trace = sample(1000)
burn = n/10
traceplot(trace[burn:])
plots.summary(trace[burn:])
def BayesianLearning(fig, path, measurements,
pos_min=-50, pos_max=50, subplot=133):
with pm.Model() as model:
# Compute bounds based on measurements
pos_min_x, pos_max_x, pos_min_y, pos_max_y = boundsFromPath(path)
minPos = min(pos_min_x, pos_min_y)
maxPos = max(pos_max_x, pos_max_y)
# Priors
# See: http://stackoverflow.com/q/25342899
thermal_position_x = pm.Uniform('thermal_position_x',
lower=pos_min_x, upper=pos_max_x)
thermal_position_y = pm.Uniform('thermal_position_y',
lower=pos_min_y, upper=pos_max_y)
thermal_amplitude = pm.Uniform('thermal_amplitude',
lower=-10, upper=10)
thermal_sd = pm.Uniform('sd', lower=0.1, upper=100)
# When sampling, look at the values of the test thermal field at the points
# we have taken measurements at.
velocity = deterministicVelocity(path, measurements,
thermal_position_x, thermal_position_y,
thermal_amplitude, thermal_sd)
# Observe the vertical velocities
thermal_vert_vel = pm.Normal('thermal_vert_vel', mu=velocity,
observed=measurements)
# Sample this to find the posterior, note Metropolis works with discrete
step = pm.Metropolis()
start = pm.find_MAP(fmin=sp.optimize.fmin_powell)
trace = pm.sample(2000, step=step, progressbar=True, start=start)
# Find the most probable surface and plot that for comparison
x = lameMAP(trace['thermal_position_x'])
y = lameMAP(trace['thermal_position_y'])
amp = lameMAP(trace['thermal_amplitude'])
sd = lameMAP(trace['sd'])
eq = thermalEq((x,y), amp, sd)
# Plot it
prev = plt.gca()
visualizeThermalField([eq], path, measurements, trace, pos_min, pos_max,
only2d=False, fig=fig, subplot=subplot, lines=False,
limits=[prev.get_xlim(),prev.get_ylim(),prev.get_zlim()])
# Really, we have more information than just this MAP estimate.
# We have probability distributions over all the parameters.
# It's hard to visualize this in one figure that we can directly
# compare with the GPR though.
pm.traceplot(trace, ['thermal_position_x','thermal_position_y',
'thermal_amplitude','sd'])
def mcmc_fit(xdata, ytime):
print("length xdata:", len(xdata))
print("length ytime:", len(ytime))
base = 2
params = [xdata[:, 1], xdata[:, 0], ytime, base]
# creating mcmc model
trace = mcmc_model(params)
traceplot(trace)
plt.close()
# [y_cal, y_cal_upper, y_cal_lower, size]
return trace
def test_categorical():
k = 3
ndata = 5000
v = np.random.randint(0, k, ndata)
with pymc3.Model() as model:
p = pymc3.Dirichlet(name='p', a=np.array([1., 1., 1.]), shape=k)
category = pymc3.Categorical(name='category',
p=p,
shape=ndata,
observed=v)
trace = pymc3.sample(3000, step=pymc3.Slice())
pymc3.traceplot(trace)
plt.show()
def plot_traces_pymc(trcs, varnames=None):
''' Convenience fn: plot traces with overlaid means and values
Handle nested traces for hierarchical models
'''
nrows = len(trcs.varnames)
if varnames is not None:
nrows = len(varnames)
ax = pm.traceplot(trcs, varnames=varnames, figsize=(12, nrows*1.4),
lines={k: v['mean'] for k, v in
pm.df_summary(trcs,varnames=varnames).iterrows()},
combined=True)
# don't label the nested traces (a bit clumsy this: consider tidying)
dfmns = pm.df_summary(trcs, varnames=varnames)['mean'].reset_index()
dfmns.rename(columns={'index':'featval'}, inplace=True)
dfmns = dfmns.loc[dfmns['featval'].apply(lambda x: re.search('__[1-9]{1,}', x) is None)]
dfmns['draw'] = dfmns['featval'].apply(lambda x: re.search('__0{1}$', x) is None)
dfmns['pos'] = np.arange(dfmns.shape[0])
dfmns.set_index('pos', inplace=True)
for i, r in dfmns.iterrows():
if r['draw']:
ax[i,0].annotate('{:.2f}'.format(r['mean']), xy=(r['mean'],0)
,xycoords='data', xytext=(5,10)
,textcoords='offset points', rotation=90
,va='bottom', fontsize='large', color='#AA0022')
def run(n=1500):
if n == 'short':
n = 50
with m:
trace = pm.sample(n)
pm.traceplot(trace, varnames=['mu_hat'])
print('Example observed data: ')
print(y[:30, :].T)
print('The true ranking is: ')
print(yreal.flatten())
print('The Latent mean is: ')
latentmu = np.hstack(([0], pm.summary(trace, varnames=['mu_hat'])['mean'].values))
print(np.round(latentmu, 2))
print('The estimated ranking is: ')
print(np.argsort(latentmu))
def plot_traces(self, fname=None, bbox_inches='tight', **kwargs):
# Should plot the MCMC traces.
axes = pm.traceplot(self.traces)
fig = axes[0, 0].get_figure()
if fname is not None:
fig.tight_layout()
fig.savefig(fname, bbox_inches=bbox_inches, **kwargs)
return fig, axes
def main():
X, Y = generate_sample()
with pm.Model() as model:
alpha = pm.Normal('alpha', mu=0, sd=20)
beta = pm.Normal('beta', mu=0, sd=20)
sigma = pm.Uniform('sigma', lower=0)
y = pm.Normal('y', mu=beta*X+alpha, sd=sigma, observed=Y)
start = pm.find_MAP()
step = pm.NUTS(state=start)
with model:
if (multicore):
trace = pm.sample(itenum, step, start=start,
njobs=chainnum, random_seed=range(chainnum), progressbar=progress)
else:
ts = [pm.sample(itenum, step, chain=i, progressbar=progress)
for i in range(chainnum)]
trace = merge_traces(ts)
if (saveimage):
pm.traceplot(trace).savefig("simple_linear_trace.png")
print "Rhat = {0}".format(pm.gelman_rubin(trace))
t1 = time.clock()
print "elapsed time = {0}".format(t1 - t0)
#trace
if(not multicore):
trace=ts[0]
with model:
pm.traceplot(trace,model.vars)
pm.forestplot(trace)
with open("simplelinearregression_model.pkl","w") as fpw:
pkl.dump(model,fpw)
with open("simplelinearregression_trace.pkl","w") as fpw:
pkl.dump(trace,fpw)
with open("simplelinearregression_model.pkl") as fp:
model=pkl.load(fp)
with open("simplelinearregression_trace.pkl") as fp:
trace=pkl.load(fp)
def test_bernoulli():
data = [random.randint(0,1) for i in range(200)]
model = pymc3.Model()
with model:
p = pymc3.Uniform(lower=0,upper=1, name='p')
X = pymc3.Bernoulli(p=p, name='X', observed=data)
start = pymc3.find_MAP()
# instantiate sampler
step = pymc3.NUTS(scaling=start)
# draw 500 posterior samples
trace = pymc3.sample(10000, step, start=start)
pymc3.traceplot(trace)
plt.show()
def __init__(self,X_train,y_train,n_hidden,lam=1):
n_train = y_train.shape[0]
n_dim = X_train.shape[1]
print X_train.shape
with pm.Model() as rbfnn:
C = pm.Normal('C',mu=0,sd=10,shape=(n_hidden))
#beta = pm.Gamma('beta',1,1)
w = pm.Normal('w',mu=0,sd=10,shape=(n_hidden+1))
#component, updates = theano.scan(fn=lambda x: T.sum(C-x)**2,sequences=[X_train])
y_out=[]
for x in X_train:
#rbf_out = T.exp(-lam*T.sum((C-x)**2,axis=1))
#1d speed up
rbf_out = T.exp(-lam*(C-x)**2)
#rbf_out = theano.printing.Print(rbf_out)
rbf_out_biased = \
T.concatenate([ rbf_out, T.alloc(1,1) ], 0)
y_out.append(T.dot(w,rbf_out_biased))
y = pm.Normal('y',mu=y_out,sd=0.01,observed=y_train)
start = pm.find_MAP(fmin=scipy.optimize.fmin_l_bfgs_b)
print start
step = pm.NUTS(scaling=start)
trace = pm.sample(2000, step, progressbar=False)
step = pm.NUTS(scaling=trace[-1])
trace = pm.sample(20000,step,start=trace[-1])
print summary(trace, vars=['C', 'w'])
vars = trace.varnames
for i, v in enumerate(vars):
for d in trace.get_values(v, combine=False, squeeze=False):
d=np.squeeze(d)
with open(str(v)+".txt","w+") as thefile:
for item in d:
print>>thefile, item
traceplot(trace)
plt.show()
def mcmc_fit(xdata, ytime, eq_used):
print("length xdata:", len(xdata))
print("length ytime:", len(ytime))
for equation in eq_used:
params = [xdata[:, 1], xdata[:, 0], ytime, equation]
# creating mcmc model
trace = mcmc_model(params)
# save the learned mode in pickle file
pickle.dump(trace, open("results/model" + str(equation) + ".pickle", "wb"), protocol=-1)
traceplot(trace)
# move plot about learned param values to results folder
os.rename("mcmc.png", "results/mcmc_" + str(equation) + ".png")
plt.close()
print("mcmc_fit finish")
# [y_cal, y_cal_upper, y_cal_lower, size]
return trace
def groundTruthTraceplot(truths,trace,var,sigma=0.01,scale=None,jitter=0.01,ymax=None,show=True,**kwargs):
ax = traceplot(trace=trace,vars=[var],**kwargs)
#Reset color cycle to match colors properly
ax[0][0].set_color_cycle(None)
#ax[0][0].set_line_style('dashed')
truths = truths.flatten()
xmin = min(truths.min(),trace[var].min())
xmax = max(truths.max(),trace[var].max())
x = np.linspace(xmin,xmax,int(1000*(xmax-xmin)))
if scale is None:
scale = len(truths)
for truth in truths:
randj = (np.random.rand()-0.5)*jitter
ax[0][0].plot(x,mlab.normpdf(x,truth+randj,sigma),'--')
if ymax is not None:
ax[0][0].set_ylim((0,ymax))
if show:
plt.show()
start_MAP = pm.find_MAP(fmin=optimize.fmin_powell)
t2 = time.time()
print("Found MAP, took %f seconds" % (t2 - t1))
## take samples
t1 = time.time()
traces_ols = pm.sample(2000, start=start_MAP, step=pm.NUTS(), progressbar=True)
print()
t2 = time.time()
print("Done sampling, took %f seconds" % (t2 - t1))
pm.summary(traces_ols)
## plot the samples and the marginal distributions
_ = pm.traceplot(
traces_ols,
figsize=(12, len(traces_ols.varnames) * 1.5),
lines={k: v["mean"] for k, v in pm.df_summary(traces_ols).iterrows()},
)
plt.show()
do_tstudent = False
if do_tstudent:
print("Robust Student-t analysis...")
t1 = time.time()
with pm.Model() as mdl_studentt:
## Define weakly informative Normal priors to give Ridge regression
with model1:
s = shared(pm.floatX(1))
inference = pm.ADVI(cost_part_grad_scale=s)
# ADVI has nearly converged
inference.fit(n=20000)
# It is time to set `s` to zero
s.set_value(0)
approx = inference.fit(n=10000)
trace = approx.sample(3000, include_transformed=True)
elbos1 = -inference.hist
chain = trace[2000:]
varnames2 = ['beta', 'beta1', 'beta2', 'beta3']
# # pm.plot_posterior(chain2, varnames2, ref_val=0)
pm.traceplot(chain)
plt.show()
pm.traceplot(chain, varnames2)
plt.show()
# 需要着重分析：'beta', 'beta1', 'beta2', 'beta3'
varnames2 = ['beta', 'beta1', 'beta2', 'beta3']
tmp = pm.df_summary(chain, varnames2)
betaMAP = tmp['mean'][np.arange(companiesABC)]
beta1MAP = tmp['mean'][np.arange(companiesABC) + companiesABC]
beta2MAP = tmp['mean'][2 * companiesABC]
beta3MAP = tmp['mean'][2 * companiesABC + 1]
from matplotlib import gridspec
plt.figure(figsize=(12, 5))
def make_dataframe(n, s):
df = pd.DataFrame({
'success': [0] * (n * 4),
'country': ['Canada'] * (2 * n) + ['China'] * (2 * n),
'treated': [0] * n + [1] * n + [0] * n + [1] * n
})
for i, successes in zip([n, n*2, n*3, n*4], s):
df.loc[i - n:i - n + successes - 1, 'success'] = 1
return df
# n, ss = 200, [60, 100, 110, 120]
n, ss = 100, [30, 50, 55, 60]
df = make_dataframe(n, ss)
le = preprocessing.LabelEncoder()
country_idx = le.fit_transform(df['country'])
n_countries = len(set(country_idx))
pm.traceplot(trace_h)
"""
def __init__(self):
self.count = 0
def __call__(self, shape):
self.count += 1
regularization = pm.HalfNormal('reg_hyper%d' % self.count, sd=1)
return pm.Normal('w%d' % self.count, mu=0, sd=regularization,
testval=np.random.normal(size=shape),
shape=shape)
if __name__ == "__main__":
print("Loading data...")
X_train, y_train, X_val, y_val, X_test, y_test = load_dataset()
# Building a theano.shared variable
input_var = theano.shared(X_train[:500, ...].astype(np.float64))
target_var = theano.shared(y_train[:500, ...].astype(np.float64))
with pm.Model() as neural_network_hier:
likelihood = build_ann(GaussWeightsHierarchicalRegularization())
v_params, trace, ppc, y_pred = run_advi(likelihood, X_train, y_train, input_var, X_test, y_test, target_var)
print('Accuracy on test data = {}%'.format(accuracy_score(y_test, y_pred) * 100))
pm.traceplot(trace, varnames=['reg_hyper1', 'reg_hyper2', 'reg_hyper3', 'reg_hyper4', 'reg_hyper5', 'reg_hyper6'])
with pm.Model() as NonCentered_eight:
tau = pm.HalfCauchy('tau', beta=5)
mu = pm.Normal('mu', mu=0, sigma=5)
theta_tilde = pm.Normal('theta_t', mu=0, sigma=1, shape=N)
theta = pm.Deterministic('theta', mu + tau * theta_tilde)
y = pm.Normal('obs', mu=theta, sigma=sigma_observed, observed=y_observed)
with Centered_eight:
centered_trace = pm.sample(5000, chains=2, tune=2000, target_accept=.99)
with NonCentered_eight:
noncentered_trace = pm.sample(5000, chains=2, tune=1000, target_accept=.80)
print('Centered')
print(pm.summary(centered_trace).round(2))
pm.traceplot(centered_trace)
print('Non Centered')
print(pm.summary(noncentered_trace).round(2))
pm.traceplot(noncentered_trace)
plt.figure()
plt.scatter(np.log(centered_trace['tau'][2000:]),
centered_trace['theta'][:, 0][2000:],
color='orange')
plt.scatter(np.log(noncentered_trace['tau'][2000:]),
noncentered_trace['theta'][:, 0][2000:],
color='green')
plt.legend(['Centered', 'Non-Centered'])
plt.show()
print('--- Model Specified ---')
#%% Model Fitting
# Maximum a posteriori (MAP) estimate for a model, is the mode of the posterior
# distribution and is generally found using numerical optimization methods
map_estimate = pm.find_MAP(model=basic_model)
map_estimate
# In summary, while PyMC3 provides the function find_MAP(), at this point mostly
# for historical reasons, this function is of little use in most scenarios.
# If you want a point estimate you should get it from the posterior.
# In the next section we will see how to get a posterior using sampling methods.
print('--- Model Fit ---')
#%% Sampling Methods
with basic_model:
# draw 500 posterior samples
trace = pm.sample(500)
print('--- Model Sampling ---')
#%% Posterior Analysis
# PyMC3 provides plotting and summarization functions for inspecting the sampling
# output. A simple posterior plot can be created using traceplot.
pm.traceplot(trace)
pm.summary(trace).round(2)
# default
k1, n1 = 5, 10
k2, n2 = 7, 10
## Exercise 3.3.1
#k1, n1 = 14, 20
#k2, n2 = 16, 20
## Exercise 3.3.2
#k1, n1 = 0, 10
#k2, n2 = 10, 10
## Exercise 3.3.3
#k1, n1 = 5, 10
#k2, n2 = 5, 10
model = pm.Model()
with model:
# Prior on single rate
theta = pm.Beta('theta', alpha=1, beta=1)
# Observed Counts
k1 = pm.Binomial('k1', p=theta, n=n1, observed=k1)
k2 = pm.Binomial('k2', p=theta, n=n2, observed=k2)
# instantiate Metropolis-Hastings sampler
stepFunc = pm.Metropolis()
# draw 5,000 posterior samples (in 4 parallel running chains)
Nsample = 5000
Nchains = 4
traces = pm.sample(Nsample, step=stepFunc, njobs=Nchains)
axs = pm.traceplot(traces, vars=['theta'], combined=False)
axs[0][0].set_xlim([0,1]) # manually set x-limits for comparisons
plt.subplot(211)
plt.title(r'Trace of $\alpha$')
plt.plot(alpha_samples, color='darkred')
plt.xlabel('Samples')
plt.ylabel('Parameter')
# Plot beta trace
plt.subplot(212)
plt.title(r'Trace of $\beta$')
plt.plot(beta_samples, color='b')
plt.xlabel('Samples')
plt.ylabel('Parameter')
plt.tight_layout(h_pad=0.8)
figsize(20, 12)
pm.traceplot(sleep_trace, ['alpha', 'beta'])
# %%
pm.autocorrplot(sleep_trace, ['alpha', 'beta'])
# Sort the values by time offset
wake_data.sort_values('time_offset', inplace=True)
# Time is the time offset
time = np.array(wake_data.loc[:, 'time_offset'])
# Observations are the indicator
wake_obs = np.array(wake_data.loc[:, 'indicator'])
with pm.Model() as wake_model:
"""
plt.scatter(x_2, y_2)
plt.xlabel('$x$', fontsize=16)
plt.ylabel('$y$', fontsize=16, rotation=0)
plt.savefig('img422.png')
"""
with pm.Model() as model_poly:
alpha = pm.Normal('alpha', mu=0, sd=10)
beta1 = pm.Normal('beta1', mu=0, sd=1)
beta2 = pm.Normal('beta2', mu=0, sd=1)
epsilon = pm.HalfCauchy('epsilon', 5)
mu = alpha + beta1 * x_2 + beta2 * x_2**2
y_pred = pm.Normal('y_pred', mu=mu, sd=epsilon, observed=y_2)
trace_poly = pm.sample(2000, njobs=1)
pm.traceplot(trace_poly)
plt.savefig('img423.png')
pm.autocorrplot(trace_poly)
plt.savefig('img4232.png')
plt.clf()
x_p = np.linspace(-6, 6)
y_p = trace_poly['alpha'].mean(
) + trace_poly['beta1'].mean() * x_p + trace_poly['beta2'].mean() * x_p**2
plt.scatter(x_2, y_2)
plt.xlabel('$x$', fontsize=16)
plt.ylabel('$y$', fontsize=16, rotation=0)
plt.plot(x_p, y_p, c='k')
plt.savefig('img424.png')
# Hyperpriors
mu_a = pm.Normal('mu_alpha', mu=clothm_mean, sd=10)
sigma_a = pm.HalfCauchy('sigma_alpha', beta=2)
mu_b = pm.Normal('mu_beta', mu=0., sd=10)
sigma_b = pm.HalfCauchy('sigma_beta', beta=2)
# Intercept for each county, distributed around group mean mu_a
a = pm.Normal('alpha', mu=mu_a, sd=sigma_a, shape=len(Data.wavecode.unique()))
# Intercept for each county, distributed around group mean mu_a
b = pm.Normal('beta', mu=mu_b, sd=sigma_b, shape=len(Data.wavecode.unique()))
# Error standard deviation
eps = pm.HalfCauchy('eps', beta=2)
# Expected value
w_est = a[wave_idx] + b[wave_idx] * Data.ltotR
# Data likelihood
w_like = pm.Normal('w_like', mu=w_est, sd=eps, observed=Data.w_clothm)
with hierarchical_model:
hierarchical_trace = pm.sample(draws=5000, tune=1000, njobs=4)[1000:]
x = pd.Series(hierarchical_trace['sigma_alpha_log'], name='sigma alpha log')
y = pd.Series(hierarchical_trace['eps_log'], name='sigma eps log')
sns.jointplot(x, y);
pm.traceplot(hierarchical_trace)
def PLD(tpf,
planet_mask=None,
aperture=None,
return_soln=False,
return_quick_corrected=False,
sigma=5,
trim=0,
ndraws=1000):
''' Use exoplanet, pymc3 and theano to perform PLD correction
Parameters
----------
tpf : lk.TargetPixelFile
Target Pixel File to Correct
planet_mask : np.ndarray
Boolean array. Cadences where planet_mask is False will be excluded from the
PLD correction. Use this to mask out planet transits.
'''
if planet_mask is None:
planet_mask = np.ones(len(tpf.time), dtype=bool)
if aperture is None:
aperture = tpf.pipeline_mask
time = np.asarray(tpf.time, np.float64)
if trim > 0:
flux = np.asarray(tpf.flux[:, trim:-trim, trim:-trim], np.float64)
flux_err = np.asarray(tpf.flux_err[:, trim:-trim, trim:-trim],
np.float64)
aper = np.asarray(aperture, bool)[trim:-trim, trim:-trim]
else:
flux = np.asarray(tpf.flux, np.float64)
flux_err = np.asarray(tpf.flux_err, np.float64)
aper = np.asarray(aperture, bool)
raw_flux = np.asarray(np.nansum(flux[:, aper], axis=(1)), np.float64)
raw_flux_err = np.asarray(
np.nansum(flux_err[:, aper]**2, axis=(1))**0.5, np.float64)
raw_flux_err /= np.median(raw_flux)
raw_flux /= np.median(raw_flux)
raw_flux -= 1
# Setting to Parts Per Thousand keeps us from hitting machine precision errors...
raw_flux *= 1e3
raw_flux_err *= 1e3
# Build the first order PLD basis
# X_pld = np.reshape(flux[:, aper], (len(flux), -1))
saturation = (np.nanpercentile(flux, 100, axis=0) > 175000)
X_pld = np.reshape(flux[:, aper & ~saturation], (len(tpf.flux), -1))
extra_pld = np.zeros((len(time), np.any(saturation, axis=0).sum()))
idx = 0
for column in saturation.T:
if column.any():
extra_pld[:, idx] = np.sum(flux[:, column, :], axis=(1, 2))
idx += 1
X_pld = np.hstack([X_pld, extra_pld])
# Remove NaN pixels
X_pld = X_pld[:, ~((~np.isfinite(X_pld)).all(axis=0))]
X_pld = X_pld / np.sum(flux[:, aper], axis=-1)[:, None]
# Build the second order PLD basis and run PCA to reduce the number of dimensions
X2_pld = np.reshape(X_pld[:, None, :] * X_pld[:, :, None], (len(flux), -1))
# Remove NaN pixels
X2_pld = X2_pld[:, ~((~np.isfinite(X2_pld)).all(axis=0))]
U, _, _ = np.linalg.svd(X2_pld, full_matrices=False)
X2_pld = U[:, :X_pld.shape[1]]
# Construct the design matrix and fit for the PLD model
X_pld = np.concatenate((np.ones((len(flux), 1)), X_pld, X2_pld), axis=-1)
# Create a matrix with small numbers along diagonal to ensure that
# X.T * sigma^-1 * X is not singular, and prevent it from being non-invertable
diag = np.diag((1e-8 * np.ones(X_pld.shape[1])))
if (~np.isfinite(X_pld)).any():
raise ValueError('NaNs in components.')
if (np.any(raw_flux_err == 0)):
raise ValueError('Zeros in raw_flux_err.')
def build_model(mask=None, start=None):
''' Build a PYMC3 model
Parameters
----------
mask : np.ndarray
Boolean array to mask cadences. Cadences that are False will be excluded
from the model fit
start : dict
MAP Solution from exoplanet
Returns
-------
model : pymc3.model.Model
A pymc3 model
map_soln : dict
Best fit solution
'''
if mask is None:
mask = np.ones(len(time), dtype=bool)
with pm.Model() as model:
# GP
# --------
logs2 = pm.Normal("logs2", mu=np.log(np.var(raw_flux[mask])), sd=4)
# pm.Potential("logs2_prior1", tt.switch(logs2 < -3, -np.inf, 0.0))
logsigma = pm.Normal("logsigma",
mu=np.log(np.std(raw_flux[mask])),
sd=4)
logrho = pm.Normal("logrho", mu=np.log(150), sd=4)
kernel = xo.gp.terms.Matern32Term(log_rho=logrho,
log_sigma=logsigma)
gp = xo.gp.GP(kernel, time[mask],
tt.exp(logs2) + raw_flux_err[mask]**2)
# Motion model
#------------------
A = tt.dot(X_pld[mask].T, gp.apply_inverse(X_pld[mask]))
A = A + diag # Add small numbers to diagonal to prevent it from being singular
B = tt.dot(X_pld[mask].T, gp.apply_inverse(raw_flux[mask, None]))
C = tt.slinalg.solve(A, B)
motion_model = pm.Deterministic("motion_model",
tt.dot(X_pld[mask], C)[:, 0])
# Likelihood
#------------------
pm.Potential("obs",
gp.log_likelihood(raw_flux[mask] - motion_model))
# gp predicted flux
gp_pred = gp.predict()
pm.Deterministic("gp_pred", gp_pred)
pm.Deterministic("weights", C)
# Optimize
#------------------
if start is None:
start = model.test_point
map_soln = xo.optimize(start=start, vars=[logsigma])
map_soln = xo.optimize(start=start, vars=[logrho, logsigma])
map_soln = xo.optimize(start=start, vars=[logsigma])
map_soln = xo.optimize(start=start, vars=[logrho, logsigma])
map_soln = xo.optimize(start=map_soln, vars=[logs2])
map_soln = xo.optimize(start=map_soln,
vars=[logrho, logsigma, logs2])
return model, map_soln, gp
# First rough correction
log.info('Optimizing roughly')
with silence():
model0, map_soln0, gp = build_model(mask=planet_mask)
# Remove outliers, make sure to remove a few nearby points incase of flares.
with model0:
motion = np.dot(X_pld, map_soln0['weights']).reshape(-1)
stellar = xo.eval_in_model(gp.predict(time), map_soln0)
corrected = raw_flux - motion - stellar
mask = ~sigma_clip(corrected, sigma=sigma).mask
mask = ~(convolve(mask, Box1DKernel(3), fill_value=1) != 1)
mask &= planet_mask
# Optimize PLD
log.info('Optimizing without outliers')
with silence():
model, map_soln, gp = build_model(mask, map_soln0)
lc_fig = _plot_light_curve(map_soln, model, mask, time, raw_flux,
raw_flux_err, X_pld, gp)
if return_soln:
motion = np.dot(X_pld, map_soln['weights']).reshape(-1)
with model:
stellar = xo.eval_in_model(gp.predict(time), map_soln)
return model, map_soln, motion, stellar
if return_quick_corrected:
raw_lc = tpf.to_lightcurve()
clc = lk.KeplerLightCurve(
time=time,
flux=(raw_flux - stellar - motion) * 1e-3 + 1,
flux_err=(raw_flux_err) * 1e-3,
time_format=raw_lc.time_format,
centroid_col=tpf.estimate_centroids()[0],
centroid_row=tpf.estimate_centroids()[0],
quality=raw_lc.quality,
channel=raw_lc.channel,
campaign=raw_lc.campaign,
quarter=raw_lc.quarter,
mission=raw_lc.mission,
cadenceno=raw_lc.cadenceno,
targetid=raw_lc.targetid,
ra=raw_lc.ra,
dec=raw_lc.dec,
label='{} PLD Corrected'.format(raw_lc.targetid))
return clc
# Burn in
sampler = xo.PyMC3Sampler()
with model:
burnin = sampler.tune(tune=np.max([int(ndraws * 0.3), 150]),
start=map_soln,
step_kwargs=dict(target_accept=0.9),
chains=4)
# Sample
with model:
trace = sampler.sample(draws=ndraws, chains=4)
varnames = ["logrho", "logsigma", "logs2"]
pm.traceplot(trace, varnames=varnames)
samples = pm.trace_to_dataframe(trace, varnames=varnames)
corner.corner(samples)
# Generate 50 realizations of the prediction sampling randomly from the chain
N_pred = 50
pred_mu = np.empty((N_pred, len(time)))
pred_motion = np.empty((N_pred, len(time)))
with model:
pred = gp.predict(time)
for i, sample in enumerate(
tqdm(xo.get_samples_from_trace(trace, size=N_pred),
total=N_pred)):
pred_mu[i] = xo.eval_in_model(pred, sample)
pred_motion[i, :] = np.dot(X_pld, sample['weights']).reshape(-1)
star_model = np.mean(pred_mu + pred_motion, axis=0)
star_model_err = np.std(pred_mu + pred_motion, axis=0)
raw_lc = tpf.to_lightcurve()
meta = {
'samples': samples,
'trace': trace,
'pred_mu': pred_mu,
'pred_motion': pred_motion
}
clc = lk.KeplerLightCurve(
time=time,
flux=(raw_flux - star_model) * 1e-3 + 1,
flux_err=((raw_flux_err**2 + star_model_err**2)**0.5) * 1e-3,
time_format=raw_lc.time_format,
centroid_col=tpf.estimate_centroids()[0],
centroid_row=tpf.estimate_centroids()[0],
quality=raw_lc.quality,
channel=raw_lc.channel,
campaign=raw_lc.campaign,
quarter=raw_lc.quarter,
mission=raw_lc.mission,
cadenceno=raw_lc.cadenceno,
targetid=raw_lc.targetid,
ra=raw_lc.ra,
dec=raw_lc.dec,
label='{} PLD Corrected'.format(raw_lc.targetid),
meta=meta)
return clc
def evaluate_fit(self, show_feats):
return pm.traceplot(self.trace_, varnames=show_feats)
with pm.Model() as model:
sigma = pm.HalfCauchy('sigma', beta=10, testval=1.0)
intercept = pm.Normal('Intercept', 0, sd=20)
x_coeff = pm.Normal('x', 0, sd=20)
likelihood = pm.Normal('y',
mu=intercept + x_coeff * x,
sd=sigma,
observed=y)
start = pm.find_MAP()
step = pm.NUTS(scaling=start)
trace = pm.sample(2000, step, start=start, progressbar=True)
plt.figure(figsize=(7, 7))
pm.traceplot(trace[100:])
plt.tight_layout()
plt.savefig("figures/glm-02.png")
plt.figure(figsize=(7, 7))
plt.plot(x, y, 'x', label='data')
pm.glm.plot_posterior_predictive(trace,
samples=100,
label='posterior predictive regression lines')
plt.plot(x, true_regression_line, label='true regression line', lw=3.0, c='y')
plt.title('Posterior predictive regression lines')
plt.legend(loc=0)
plt.xlabel('x')
plt.ylabel('y')
plt.savefig("figures/glm-03.png")
plt.show()
def posterior_traceplot(self, **kwargs):
return pm.traceplot(self.posterior_, **kwargs)
def mcmc_changepoint(dates,
ratings,
mcmc_iter=1000,
discrete=0,
plot_result=1):
"""This function models Yelp reviews as coming from two normal distributions
with a switch point somewhere between them. When left of the switch point then
reviews are drawn from the first normal distribution. To the right of the
switch point reviews are drawn from the second normal distribution. Normal
distributions are used if the reviews have been normalized to the user's
average rating; otherwise if analyzing in terms of 1-5 stars set discrete=1
and the function will do the same estimation on Poisson distributions. This
function then finds the most likely distribution for where the switchpoint is
and the most likely parameters for the two generator distributions by using
Metropolis-Hastings sampling and Hamiltonian Monte Carlo."""
# dates: Array of dates when the reviews were posted
# ratings: Array of the ratings given by each review
# mcmc_iter: How many iterations of the MCMC to run?
# discrete: Should I use Normal or Poisson distributions to model the ratings?
# (i.e. are the user-averaged or 1-5 stars)
# plot_result: Should the function output a plot?
number_of_ratings = np.arange(0, len(ratings))
if discrete == 0:
with Model() as switch_model:
switchpoint = DiscreteUniform('switchpoint',
lower=0,
upper=len(dates))
before_intensity = Normal('before_intensity', mu=0, sd=1)
after_intensity = Normal('after_intensity', mu=0, sd=1)
intensity = switch(switchpoint >= number_of_ratings,
before_intensity, after_intensity)
sigma = HalfNormal('sigma', sd=1)
rating = Normal('rating', mu=intensity, sd=sigma, observed=ratings)
elif discrete == 1:
with Model() as switch_model:
switchpoint = DiscreteUniform('switchpoint',
lower=0,
upper=len(dates))
before_intensity = Exponential('before_intensity', 1)
after_intensity = Exponential('after_intensity', 1)
intensity = switch(switchpoint >= number_of_ratings,
before_intensity, after_intensity)
rating = Poisson('rating', intensity, observed=ratings)
with switch_model:
trace = sample(mcmc_iter)
if plot_result == 1:
traceplot(trace)
plt.show()
switch_posterior = trace['switchpoint']
N_MCs = switch_posterior.shape[0]
before_intensity_posterior = trace['before_intensity']
after_intensity_posterior = trace['after_intensity']
expected_stars = np.zeros(len(ratings))
for a_rating in number_of_ratings:
where_switch = a_rating < switch_posterior
expected_stars[a_rating] = (
before_intensity_posterior[where_switch].sum() +
after_intensity_posterior[~where_switch].sum()) / N_MCs
if plot_result == 1:
plt.plot(dates, ratings, 'o')
plt.plot(dates, expected_stars, 'b-')
plt.show()
# Return the mode and it's frequency / mcmc_iter
b_mean, b_count = scipy.stats.mode(trace['before_intensity'])
a_mean, a_count = scipy.stats.mode(trace['after_intensity'])
modal_switch, count = scipy.stats.mode(trace['switchpoint'])
sigma_est, sigma_count = scipy.stats.mode(trace['sigma'])
differential = b_mean - a_mean
return differential, modal_switch, expected_stars, sigma_est, switch_posterior
%config InlineBackend.figure_format = 'retina'
%matplotlib inline
plt.rcParams["figure.figsize"] = (10, 5)
np.random.seed(42)
# Prepare the data
Ns = [90, 50, 80]
mus = [4, 10, 20]
sds = [0.5, 4, 1.5]
mix = np.array([])
for N, mu, sd in zip(Ns, mus, sds):
mix = np.append(mix, norm(mu, sd).rvs(N))
# Sampling
n = len(Ns)
with pm.Model() as model:
p = pm.Dirichlet("p", np.ones(n))
k = pm.Categorical("k", p=p, shape=sum(Ns))
means = pm.Normal("means", mu=[10, 10, 10], sd=10, shape=n)
sigmas = pm.HalfCauchy("sigmas", 5, shape=n)
y = pm.Normal("y", mu=means[k], sd=sigmas[k], observed=mix)
trace = pm.sample(5000, tune=1000)
# Plot
pm.traceplot(
trace,
varnames=["means", "p", "sigmas"],
lines={"means": mus, "sigmas":sds}
)
plt.savefig("./results/4-23-mixture-model.png")
np.random.seed(314)
N = 100
alfa_real = 2.5
beta_real = 0.9
eps_real = np.random.normal(0, 0.5, size=N)
x = np.random.normal(10, 1, N)
y_real = alfa_real + beta_real * x
y = y_real + eps_real
with pm.Model() as model_n:
alpha = pm.Normal('alpha', mu=0, sd=10)
beta = pm.Normal('beta', mu=0, sd=1)
epsilon = pm.HalfCauchy('epsilon', 5)
mu = alpha + beta * x
y_pred = pm.Normal('y_pred', mu=mu, sd=epsilon, observed=y)
rb = pm.Deterministic('rb', (beta * x.std() / y.std())**2)
y_mean = y.mean()
ss_reg = pm.math.sum((mu - y_mean)**2)
ss_tot = pm.math.sum((y - y_mean)**2)
rss = pm.Deterministic('rss', ss_reg / ss_tot)
start = pm.find_MAP()
step = pm.NUTS()
trace_n = pm.sample(2000, step=step, start=start)
pm.traceplot(trace_n)
plt.show()
with pm.Model() as model_t:
alpha = pm.Normal('alpha', mu=0, sd=100)
beta = pm.Normal('beta', mu=0, sd=1)
epsilon = pm.HalfCauchy('epsilon', 5)
nu = pm.Deterministic('nu', pm.Exponential('nu_', 1 / 29) + 1)
y_pred = pm.StudentT('y_pred',
mu=alpha + beta * x_3,
sd=epsilon,
nu=nu,
observed=y_3)
start = pm.find_MAP()
step = pm.Metropolis()
trace_t = pm.sample(2000, step=step, start=start)
pm.traceplot(trace_t)
plt.figure()
beta_c, alpha_c = stats.linregress(x_3, y_3)[:2]
plt.plot(x_3, (alpha_c + beta_c * x_3), 'k', label='non-robust', alpha=0.5)
plt.plot(x_3, y_3, 'bo')
alpha_m = trace_t['alpha'].mean()
beta_m = trace_t['beta'].mean()
plt.plot(x_3, alpha_m + beta_m * x_3, c='k', label='robust')
plt.xlabel('$x$', fontsize=16)
plt.ylabel('$y$', rotation=0, fontsize=16)
plt.legend(loc=2, fontsize=12)
plt.tight_layout()
def traceplot(self):
"""Generate a traceplot for MCMC diagnostics."""
pm.traceplot(self.trace)
y = pm.Binomial('y', p=theta, n=N, observed=z)
trace = pm.sample(5000, step=pm.NUTS(), progressbar=False)
## Check the results.
burnin = 0 # posterior samples to discard
## Print summary for each trace
#pm.df_summary(trace[burnin:])
#pm.df_summary(trace)
## Check for mixing and autocorrelation
#pm.autocorrplot(trace, varnames=['mu', 'kappa'])
## Plot KDE and sampled values for each parameter.
#pm.traceplot(trace[burnin:])
pm.traceplot(trace)
# Create arrays with the posterior sample
mu1_sample = trace['mu'][:,0][burnin:]
mu2_sample = trace['mu'][:,1][burnin:]
mu3_sample = trace['mu'][:,2][burnin:]
mu4_sample = trace['mu'][:,3][burnin:]
# Plot differences among filtrations experiments
fig, ax = plt.subplots(1, 3, figsize=(15, 6))
pm.plot_posterior((mu1_sample-mu2_sample), ax=ax[0], ref_val=0, color='skyblue')
ax[0].set_xlabel(r'$\mu1-\mu2$')
# Plot differences among condensation experiments
pm.plot_posterior((mu3_sample-mu4_sample), ax=ax[1], ref_val=0, color='skyblue')
ObservedA = pm.Normal('ObservedA',
mu=theta,
sd=sigma,
observed=elec_faults) # 观测值
ObservedB = pm.Normal('ObservedB',
mu=thetaB,
sd=sigma,
observed=elec_faultsB) # 观测值
start = pm.find_MAP()
# step = pm.Metropolis()
# trace2 = pm.sample(nuts_kwargs={'target_accept': 0.95})
trace2 = pm.sample(3000, tune=1000)
chain2 = trace2
varnames1 = ['σ_a', 'σ_aB', 'theta1', 'theta1B']
pm.traceplot(chain2, varnames1)
plt.show()
varnames1 = ['a0', 'sigma', 'δ', 'δB', 'Δ_a', 'Δ_aB']
pm.traceplot(chain2, varnames1)
plt.show()
plt.plot(trace2['step_size_bar'])
plt.show()
pm.energyplot(chain2)
plt.show()
# 画出自相关曲线
varnames1 = ['σ_a', 'a0', 'δ', 'σ_aB', 'Δ_a', 'δB']
pm.autocorrplot(chain2, varnames1)
plt.show()
def bayesian_t(df, val_col, grp_col='regulated',
sig_fac=2, unif_l=0, unif_u=20,
exp_mn=30,
plot_trace=False, plot_ppc=False,
plot_vars=False, plot_diffs=True,
steps=2000, mcmc='metropolis'):
""" Simple Bayesian test for differences between two groups.
Args:
df Dataframe. Must have a column containing values
and a categorical 'regulated' column that is [0, 1]
to define the two groups
val_col Name of the values column
grp_col Name of the categorical column defining the groups
sig_fac Factor applied to std. dev. of pooled data to define
prior std. dev. for group means
unif_l Lower bound for uniform prior on std. dev. of group
means
unif_u Upper bound for uniform prior on std. dev. of group
means
exp_mn Mean of exponential prior for v in Student-T
distribution
plot_trace Whether to plot the MCMC traces
plot_ppc Whether to perform and plot the Posterior Predictive
Check
plot_vars Whether to plot posteriors for variables
plot_diffs Whether to plot posteriors for differences
steps Number of steps to take in MCMC chains
mcmc Sampler to use: ['metropolis', 'slice', 'nuts']
Returns:
Creates plots showing the distribution of differences in
means and variances, plus optional diagnostics. Returns the
MCMC trace
"""
import numpy as np
import pymc3 as pm
import pandas as pd
import seaborn as sn
import matplotlib.pyplot as plt
# Get overall means and s.d.
mean_all = df[val_col].mean()
std_all = df[val_col].std()
# Group data
grpd = df.groupby(grp_col)
# Separate groups
reg_data = grpd.get_group(1)[val_col].values
ureg_data = grpd.get_group(0)[val_col].values
# Setup model
with pm.Model() as model:
# Priors for means of Student-T dists
reg_mean = pm.Normal('regulated_mean', mu=mean_all, sd=std_all*sig_fac)
ureg_mean = pm.Normal('unregulated_mean', mu=mean_all, sd=std_all*sig_fac)
# Priors for std. dev. of Student-T dists
reg_std = pm.Uniform('regulated_std', lower=unif_l, upper=unif_u)
ureg_std = pm.Uniform('unregulated_std', lower=unif_l, upper=unif_u)
# Prior for v of Student-T dists
nu = pm.Exponential('v_minus_one', 1./29.) + 1
# Define Student-T dists
# PyMC3 uses precision = 1 / (sd^2) to define dists rather than std. dev.
reg_lam = reg_std**-2
ureg_lam = ureg_std**-2
reg = pm.StudentT('regulated', nu=nu, mu=reg_mean, lam=reg_lam, observed=reg_data)
ureg = pm.StudentT('unregulated', nu=nu, mu=ureg_mean, lam=ureg_lam, observed=ureg_data)
# Quantities of interest (difference of means and std. devs.)
diff_of_means = pm.Deterministic('difference_of_means', reg_mean - ureg_mean)
diff_of_stds = pm.Deterministic('difference_of_stds', reg_std - ureg_std)
# Run sampler to approximate posterior
if mcmc == 'metropolis':
trace = pm.sample(steps, step=pm.Metropolis())
elif mcmc == 'slice':
trace = pm.sample(steps, step=pm.Slice())
elif mcmc == 'nuts':
trace = pm.sample(steps)
else:
raise ValueError("mcmc must be one of ['metropolis', 'slice', 'nuts']")
# Plot results
# Raw data
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(14,4))
for name, grp in grpd:
sn.distplot(grp[val_col].values, ax=axes[name], kde=False)
axes[name].set_title('Regulated = %s' % name)
# Traces
if plot_trace:
pm.traceplot(trace)
# Posteriors for variables
if plot_vars:
pm.plot_posterior(trace[1000:],
varnames=['regulated_mean', 'unregulated_mean',
'regulated_std', 'unregulated_std'],
alpha=0.3)
# Posteriors for differences
if plot_diffs:
pm.plot_posterior(trace[1000:],
varnames=['difference_of_means', 'difference_of_stds'],
ref_val=0,
alpha=0.3)
# Posterior predictive check
if plot_ppc:
ppc = pm.sample_ppc(trace, samples=500, model=model, size=100)
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(14,4))
sn.distplot([n.mean() for n in ppc['unregulated']], ax=axes[0])
axes[0].axvline(ureg_data.mean(), c='k')
axes[0].set(title='Posterior predictive of the mean (unregulated)',
xlabel='Mean',
ylabel='Frequency')
sn.distplot([n.mean() for n in ppc['regulated']], ax=axes[1])
axes[1].axvline(reg_data.mean(), c='k')
axes[1].set(title='Posterior predictive of the mean (regulated)',
xlabel='Mean',
ylabel='Frequency')
return trace
beta2 = pm.Normal('beta2', mu_2, sd_2, shape=companiesABC)
beta1 = pm.Normal('beta1', mu_1, sd_1, shape=companiesABC)
beta = pm.Normal('beta', 0, 100)
u = pm.Normal('u', 0, 0.01)
beta_mu = pm.Deterministic('beta_mu', tt.exp(u + beta + \
(beta1[Num_shared] * xs_year + beta2[Num_shared] * xs_char1 +\
beta3[Num_shared] * xs_char2 + beta4[Num_shared] * xs_year * xs_year)))
Observed = pm.Weibull("Observed",
alpha=alpha,
beta=beta_mu,
observed=ys_faults) # 观测值
trace_1 = pm.sample(10000, init='advi+adapt_diag')
pm.traceplot(trace_1,
varnames=['beta', 'beta1', 'beta2', 'beta3', 'beta4', 'u'])
plt.show()
burnin = 9000
chain = trace_1[burnin:]
# get MAP estimate
varnames2 = ['beta', 'beta1', 'beta2', 'beta3', 'beta4', 'u']
tmp = pm.df_summary(chain, varnames2)
betaMAP = tmp['mean'][0]
beta1MAP = tmp['mean'][np.arange(companiesABC) + 1]
beta2MAP = tmp['mean'][np.arange(companiesABC) + 1 * companiesABC + 1]
beta3MAP = tmp['mean'][np.arange(companiesABC) + 2 * companiesABC + 1]
beta4MAP = tmp['mean'][np.arange(companiesABC) + 3 * companiesABC + 1]
uMAP = tmp['mean'][4 * companiesABC + 1]
# am0MAP = tmp['mean'][4*companiesABC+2]
# am1MAP = tmp['mean'][4*companiesABC+3]
steps = pm.Metropolis()
trace = pm.sample(20000, steps, start=start, progressbar=True)
# EXAMINE THE RESULTS
burnin = 2000
thin = 50
# Print summary for each trace
#pm.summary(trace[burnin::thin])
#pm.summary(trace)
# Check for mixing and autocorrelation
#pm.autocorrplot(trace[burnin::thin], vars=model.unobserved_RVs[:-1])
## Plot KDE and sampled values for each parameter.
pm.traceplot(trace[burnin::thin])
#pm.traceplot(trace)
# Extract values of 'a'
a0_sample = trace['a0'][burnin::thin]
b1_sample = trace['b1'][burnin::thin]
b2_sample = trace['b2'][burnin::thin]
b1b2_sample = trace['b1b2'][burnin::thin]
b0_sample = a0_sample * np.std(y) + np.mean(y)
b1_sample = b1_sample * np.std(y)
b2_sample = b2_sample * np.std(y)
b1b2_sample = b1b2_sample * np.std(y)
theta_real = 0.35 # unkwon value in a real experiment
alpha_prior = 1
beta_prior = 1
data = stats.bernoulli.rvs(p=theta_real, size=n_experiments)
data_sum = data.sum()
with pm.Model() as our_first_model:
# a priori
theta = pm.Beta('theta', alpha=1, beta=1)
# likelihood
y = pm.Bernoulli('y', p=theta, observed=data)
#y = pm.Binomial('theta',n=n_experimentos, p=theta, observed=sum(datos))
start = pm.find_MAP()
step = pm.Metropolis()
trace = pm.sample(2000, step=step, start=start, nchains=1)
burnin = 0 # no burnin
chain = trace[burnin:]
pm.traceplot(chain, lines={'theta': theta_real})
plt.figure()
x = np.linspace(.2, .6, 1000)
func = stats.beta(a=alpha_prior + data_sum,
b=beta_prior + n_experiments - data_sum)
y = func.pdf(x)
plt.plot(x, y, 'r-', lw=3, label='True distribution')
plt.hist(chain['theta'],
bins=30,
normed=True,
label='Estimated posterior distribution')
from data.data_generation import generate_data
from visualizing.plot_kde import plot_kde
from visualizing.predictive_uncertaity import plot_predictive_uncertainty
# HOW TO USE THE MODEL
if __name__ == '__main__':
n = 500
d = 5
# generating data example
train_X, test_X, train_y, test_y = generate_data(n, d, 0.2)
train_X, test_X = _adding_intecept(train_X), _adding_intecept(test_X)
# using model example
model = Model(n_draws=1000, init_model=None)
model.fit(train_X, train_y)
pred, err = model.predict(test_X, with_error=True)
pm.traceplot(model.trace)
# plotting uncertainty plots example
plot_predictive_uncertainty(test_X, test_y, pred, err)
# plotting kde for given samples example
fig, ax = plt.subplots()
coef = model.trace['w'].T
for w in coef:
plot_kde(w, ax=ax)
# display the plots
plt.show()
)
assert_array_almost_equal(
hierarchical_trace['hyper_alpha_mu'][-5:],
[ 2.72175 , 2.72175 , 2.72175 , 2.533818, 2.533818]
)
assert_array_almost_equal(
hierarchical_trace['hyper_beta_mu'][-5:],
[ 0.243719, 0.237223, 0.237223, 0.237223, 0.206227]
)
# ## Model Checking
# In[15]:
pm.traceplot(hierarchical_trace[25000:], varnames=['mu', 'hyper_alpha_mu', 'hyper_beta_mu']);
# In[16]:
x_lim = 60
n_burn = 25000
# we discard burn-in and use every 1000th trace
y_pred = hierarchical_trace.get_values('y_pred')[n_burn::1000].ravel()
sns.set_style('white')
fig, ax = plt.subplots(2, sharex=True, figsize=(12,6))
ax[0].hist(y_pred, range=[0, x_lim], bins=x_lim, histtype='stepfilled')
ax[0].set_xlim(1, x_lim)
assert_almost_equal(trace['sigma'][1002], 13.8586428904)
# In[9]:
assert_almost_equal(trace['alpha'][1125:1130], [ 0.53256295, -0.57260872, 1.68859471, 0.31409282, -1.54722002])
assert_almost_equal(trace['beta'][145:150], [ 0.14140093, 0.14140093, 0.13782623, 0.13112726, 0.13281072])
assert_almost_equal(trace['sigma'][670:675], [ 18.09469578, 21.51386513, 13.30334073, 14.80010898, 19.32803484])
# # Visualizing
# In[10]:
sns.set_style('darkgrid')
pm.traceplot(trace[-1000:], ['alpha', 'beta', 'sigma'])
plt.show()
# In[11]:
n_samples = 1000
x = local.Distance.values
y = local.AirTime.values
sns.set_style('white')
fig, ax = plt.subplots()
ax.scatter(x, y, c=sns.xkcd_rgb['denim blue'], label = 'Sample Data')
def run(n=2000):
model = build_model()
with model:
trace = pm.sample(n, nuts_kwargs={'target_accept':.99})
pm.traceplot(trace)
import matplotlib.pyplot as plt
from pymc_fit import ReadData
curr_dir = os.path.dirname(os.path.realpath(__file__))
trained_file_paths = [
os.path.abspath(fp) for fp in glob.glob(os.path.join(curr_dir, '*.pkl'))
]
result_dir = os.path.dirname(curr_dir, 'result')
if not os.path.isdir(result_dir): os.mkdir(result_dir)
for trained_file_path in trained_file_paths:
model_name = os.path.basename(trained_file_path)[:-4]
with open(trained_file_path, 'rb') as trained_file_obj:
trained_trace = pickle.load(trained_file_obj)
axes = pm.traceplot(trace=trained_trace)
axes[0][0].figure.savefig(
os.path.join(result_dir, 'parameters_plot_{}.png'.format(model_name)))
plt.figure()
plt.title('Log volatility')
plt.plot(trained_trace['s'].T, 'b', alpha=.03)
plt.xlabel('Time')
plt.ylabel('Log volatility')
plt.title('Fig 2. ln(volatility)')
plt.savefig(
os.path.join(result_dir, 'log_volatility_{}.png'.format(model_name)))
returns = ReadData().train['vwretd'].as_matrix()
plt.figure()
plt.plot(np.abs(returns))
s['p_logodds'],
map_est['p_logodds'],
model.logp(map_est)))
# By default `basinhopping` uses a gradient minimization technique,
# `fmin_bfgs`, resulting in inaccurate predictions many times. If we force
# `basinhoping` to use a non-gradient technique we get much better results
with model:
for i in range(n+1):
s = {'p_logodds': 0.0, 'surv_sim': i}
map_est = mc.find_MAP(start=s, vars=model.vars,
fmin=bh, minimizer_kwargs={"method": "Powell"})
print('surv_sim: %i->%i, p: %f->%f, LogP:%f'%(s['surv_sim'],
map_est['surv_sim'],
s['p_logodds'],
map_est['p_logodds'],
model.logp(map_est)))
# Confident in our MAP estimate we can sample from the posterior, making sure
# we use the `Metropolis` method for our discrete variables.
with model:
step1 = mc.step_methods.HamiltonianMC(vars=[p])
step2 = mc.step_methods.Metropolis(vars=[surv_sim])
with model:
trace = mc.sample(25000, [step1, step2], start=map_est)
mc.traceplot(trace);
def run(n=1000):
if n == "short":
n = 50
with model:
trace = pm.sample(n)
pm.traceplot(trace, varnames=["x"])
# and the other indexes the shape of the parameter. Thus for this example: # In[8]: trace[y].shape # Out[8]: # (3000, 2, 1) # `traceplot` is a summary plotting function for a trace. # In[9]: pm.traceplot(trace); # Out[9]: # image file: # ## PyMC Internals # # ### Model # # The `Model` class has very simple internals: just a list of unobserved variables (`Model.vars`) and a list of factors which go into computing the posterior density (`Model.factors`) (see model.py for more). # # A Python "`with model:`" block has `model` as the current model. Many functions, like `find_MAP` and `sample`, must be in such a block to work correctly by default. They look in the current context for a model to use. You may also explicitly specify the model for them to use. This allows us to treat the current model as an implicit parameter to these functions. # # ### Distribution Classes
# similar notation to PyMC2 can be used for simple distributions
@theano.compile.ops.as_op(itypes=[t.lscalar, t.dscalar, t.dscalar],
otypes=[t.dvector])
def rate(switchpoint, early_mean, late_mean):
out = np.empty(len(data))
out[:switchpoint] = early_mean
out[switchpoint:] = late_mean
return out.flatten()
# need to explicitly define inputs for "rate" to run
accidents = pm.Poisson('accidents',
mu=rate(switchpoint, early_mean, late_mean),
observed=data)
# no support for dag in PyMC3
# we do it with theano instead
# install pydotprint for python 3: ' pip3 install pydotprint '
# install graphviz
# pydotprint(inferAccidents_Model.logpt)
# define iteration start
start = pm.find_MAP()
# MCMC in PyMC3
step = pm.Metropolis()
trace = pm.sample(1e4, start=start, step=step, model=inferAccidents_Model)
# show our amazing results
pm.traceplot(trace[0:])
plt.show()
from pymc3 import find_MAP map_estimate = find_MAP(model=basic_model) print(map_estimate) from scipy import optimize map_estimate = find_MAP(model=basic_model, fmin=optimize.fmin_powell) print(map_estimate) from pymc3 import NUTS, sample with basic_model: # obtain starting values via MAP start = find_MAP(fmin=optimize.fmin_powell) # instantiate sampler step = NUTS(scaling=start) # draw 2000 posterior samples trace = sample(2000, step, start=start) trace['alpha'][-5:] from pymc3 import traceplot traceplot(trace) from pymc3 import summary summary(trace['alpha'])
data = np.array([51.06, 55.12, 53.73, 50.24, 52.05, 56.40, 48.45, 52.34, 55.65, 51.49, 51.86, 63.43, 53.00, 56.09, 51.93, 52.31, 52.33, 57.48, 57.44, 55.14, 53.93, 54.62, 56.09, 68.58, 51.36, 55.47, 50.73, 51.94, 54.95, 50.39, 52.91, 51.5, 52.68, 47.72, 49.73, 51.82, 54.99, 52.84, 53.19, 54.52, 51.46, 53.73, 51.61, 49.81, 52.42, 54.3, 53.84, 53.16])
quantile = np.percentile(data, [25, 75])
iqr = quantile[1] - quantile[0]
upper = quantile[1] + iqr * 1.5
lower = quantile[0] - iqr * 1.5
clean_data = data[(data > lower) & (data < upper)]
sns.kdeplot(data)
plt.xlabel('$x$', fontsize=16)
with pm.Model() as Gaussian_model:
mu = pm.Uniform('mu', lower=40, upper=70)
sigma = pm.HalfNormal('sigma', sd=10)
y = pm.Normal('y', mu=mu, sd=sigma, observed=data)
trace = pm.sample(1100)
chain = trace[100:]
pm.traceplot(chain)
# summarize
pm.summary(chain)
# predictive sample
y_pred = pm.sample_ppc(chain, 100, Gaussian_model, size=len(data))
sns.kdeplot(data, color='b')
for draw in y_pred['y']:
sns.kdeplot(draw.flatten(), color='r', alpha=0.1)
plt.title('Gaussian model', fontsize=16)
plt.xlabel('$x$', fontsize=16)
>>>>>>>>>>>>>>>>>> Gaussian robust inferences <<<<<<<<<<<<<<<<<<<<< #
plt.figure(figsize=(8, 6))
x = np.linspace(-10, 10, 200)
trace = mc.sample(nsamples, step=step, start=start, njobs=self.njobs, trace=backend)
return trace
if __name__ == "__main__":
def real_func():
x = np.linspace(0.01, 1.0, 10)
f = x + np.random.randn(len(x))*0.01
return f
def model_func(beta):
x = np.linspace(0.01, 1.0, 10)
f = beta
return f
data = real_func()
tau_obs = np.eye(10)/.01**2
tau_prior = np.eye(10)/1.0**2
beta_prior = np.ones_like(data)*1.0
beta_map = np.linspace(0.01, 1.0, 10) + np.random.randn(10)*0.1
sampler = MCMCSampler(model_func, data, tau_obs, beta_prior, tau_prior, beta_map, is_cov=False, method=None)
trace = sampler.sample(2000)
mc.summary(trace)
mc.traceplot(trace)
plt.figure()
plt.plot(beta_map, label='ACTUAL')
plt.plot(np.mean(trace['beta'][:,:], axis=0), label='MCMC')
plt.show()
def run(n=2000):
model = build_model()
with model:
trace = pm.sample(n, nuts_kwargs={'target_accept': .99})
pm.traceplot(trace)
def robust_lin_reg(df, var_map,
steps=2000, mcmc='metropolis',
plot_trace=True, plot_vars=True):
""" Robust Bayesian linear regression.
Args:
df Dataframe. Must have a column containing values
and a categorical 'regulated' column that is [0, 1]
to define the two groups
val_map Dict specifying x and y vars: {'x':'expl_var',
'y':'resp_var'}
steps Number of steps to take in MCMC chains
mcmc Sampler to use: ['metropolis', 'slice', 'nuts']
plot_trace Whether to plot the MCMC traces
plot_vars Whether to plot posteriors for variables
Returns:
Creates plots showing the distribution of differences in
means and variances, plus optional diagnostics. Returns the
MCMC trace
"""
import pymc3 as pm
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import theano
# Get cols
df = df[var_map.values()]
# Swap keys and values
var_map_rev = dict((v,k) for k,v in var_map.iteritems())
# Convert df columns to x and y
df.columns = [var_map_rev[i] for i in df.columns]
with pm.Model() as model:
# Priors
nu = pm.Exponential('v_minus_one', 1./29.) + 1
# The patsy string below automatically assumes mu=0 and estimates
# lam = (1/s.d.**2), so don't need to add these. Do need to add
# prior for nu though.
family = pm.glm.families.StudentT(nu=nu)
# Define model
pm.glm.glm('y ~ x', df, family=family)
# Find MAP as starting point
start = pm.find_MAP()
# Run sampler to approximate posterior
if mcmc == 'metropolis':
step = pm.Metropolis()
trace = pm.sample(steps, step, start=start)
elif mcmc == 'slice':
step = pm.Slice()
trace = pm.sample(steps, step, start=start)
elif mcmc == 'nuts':
step = pm.NUTS(scaling=start)
trace = pm.sample(steps, step)
else:
raise ValueError("mcmc must be one of ['metropolis', 'slice', 'nuts']")
# Traces
if plot_trace:
pm.traceplot(trace)
# Posteriors for variables
if plot_vars:
pm.plot_posterior(trace[-1000:],
varnames=['v_minus_one', 'lam'],
alpha=0.3)
pm.plot_posterior(trace[1000:],
varnames=['x', 'Intercept'],
ref_val=0,
alpha=0.3)
# PPC
fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(111, xlabel=var_map['x'], ylabel=var_map['y'])
ax.scatter(df.x, df.y, marker='o', label='Data')
pm.glm.plot_posterior_predictive(trace, samples=50, eval=df.x,
label='PPC', alpha=0.3)
return trace
'mu',
tt.exp(beta[companyABC] + beta1[companyABC] * elec_year +
beta2 * elec_tem))
# Observed_pred = pm.Weibull("Observed_pred", alpha=mu, beta=sigma, shape=elec_faults.shape) # 观测值
Observed = pm.Weibull("Observed",
alpha=mu,
beta=sigma,
observed=elec_faults) # 观测值
# start = pm.find_MAP()
# step = pm.Metropolis([Observed])
trace2 = pm.sample(1000)
chain2 = trace2
varnames1 = ['sigma', 'mu']
pm.traceplot(chain2)
plt.show()
print(pm.dic(trace2, unpooled_model))
print(pm.df_summary(trace2, varnames1))
# com_pred = chain2.get_values('Observed_pred')[:].ravel()
# plt.hist(com_pred, range=[0, 2], bins=130, histtype='stepfilled')
# plt.axvline(elec_faults.mean(), color='r', ls='--', label='True mean')
# plt.show()
# # 画出自相关曲线
# pm.autocorrplot(chain2, varnames2)
# plt.show()
#
with unpooled_model:
post_pred = pm.sample_ppc(trace2, samples=1000)
plt.figure()
N_samples = [30, 30, 30] # total number of each groups
G_samples = [18, 18, 18] # record of the number of good-quality samples
group_idx = np.repeat(np.arange(len(N_samples)), N_samples)
data = []
for i in range(0, len(N_samples)):
data.extend(np.repeat([1, 0], [G_samples[i], N_samples[i]-G_samples[i]]))
print(group_idx, data)
base_name = os.path.basename(__file__)[:-3]
with pm.Model() as model_h,\
matplotlib.backends.backend_pdf.PdfPages('%s.pdf' % base_name) as pdf_all:
# prior
alpha = pm.HalfCauchy('alpha', beta=10)
beta = pm.HalfCauchy('beta', beta=10)
theta = pm.Beta('theta', alpha, beta, shape=len(N_samples))
# likehood
y = pm.Bernoulli('y', p=theta[group_idx], observed=data)
trace = pm.sample(2000, njobs=1)
chain = trace[200:]
fig = plt.figure()
pm.traceplot(chain)
pdf_all.savefig()
# mean, standard deviation, and the HPD intervals
print(pm.summary(trace))
alpha = pm.Normal('alpha', mu=0, sd=10)
beta = pm.Normal('beta', mu=0, sd=10)
mu = alpha + pm.math.dot(x_0, beta)
theta = pm.Deterministic('theta', 1 / (1 + pm.math.exp(-mu)))
bd = pm.Deterministic('bd', -alpha / beta)
yl = pm.Bernoulli('yl', theta, observed=y_0)
start = pm.find_MAP()
step = pm.NUTS()
trace_0 = pm.sample(5000, step, start)
chain_0 = trace_0[100:]
varnames = ['alpha', 'beta', 'bd']
pm.traceplot(chain_0, varnames)
plt.show()
theta = chain_0['theta'].mean(axis=0)
idx = np.argsort(x_0)
plt.plot(x_0[idx], theta[idx], color='b', lw=3)
plt.axvline(chain_0['bd'].mean(), ymax=1, color='r')
bd_hpd = pm.hpd(chain_0['bd'])
plt.fill_betweenx([0, 1], bd_hpd[0], bd_hpd[1], color='r', alpha=0.5)
plt.plot(x_0, y_0, 'o', color='k')
theta_hpd = pm.hpd(chain_0['theta'])[idx]
plt.fill_between(x_0[idx],
theta_hpd[:, 0],
theta_hpd[:, 1],
color='b',
