def make_model(n_fmesh=11, fmesh_is_obsmesh=False):
x = np.arange(-1., 1., .1)
# Prior parameters of C
nu = pm.Uniform('nu', 1., 3, value=1.5)
phi = pm.Lognormal('phi', mu=.4, tau=1, value=1)
theta = pm.Lognormal('theta', mu=.5, tau=1, value=1)
# The covariance dtrm C is valued as a Covariance object.
@pm.deterministic
def C(eval_fun=gp.matern.euclidean, diff_degree=nu, amp=phi, scale=theta):
return gp.NearlyFullRankCovariance(eval_fun,
diff_degree=diff_degree,
amp=amp,
scale=scale)
# Prior parameters of M
a = pm.Normal('a', mu=1., tau=1., value=1)
b = pm.Normal('b', mu=.5, tau=1., value=0)
c = pm.Normal('c', mu=2., tau=1., value=0)
# The mean M is valued as a Mean object.
def linfun(x, a, b, c):
return a * x**2 + b * x + c
@pm.deterministic
def M(eval_fun=linfun, a=a, b=b, c=c):
return gp.Mean(eval_fun, a=a, b=b, c=c)
# The actual observation locations
actual_obs_locs = np.linspace(-.8, .8, 4)
if fmesh_is_obsmesh:
o = actual_obs_locs
fmesh = o
else:
# The unknown observation locations
o = pm.Normal('o', actual_obs_locs, 1000., value=actual_obs_locs)
fmesh = np.linspace(-1, 1, n_fmesh)
# The GP submodel
sm = gp.GPSubmodel('sm', M, C, fmesh)
# Observation variance
V = pm.Lognormal('V', mu=-1, tau=1, value=.0001)
observed_values = pm.rnormal(actual_obs_locs**2, 10000)
# The data d is just array-valued. It's normally distributed about GP.f(obs_x).
d = pm.Normal('d',
mu=sm.f(o),
tau=1. / V,
value=observed_values,
observed=True)
return locals()
def test_airline(self):
# Create problem data.
E = 6
C = 2
P = 6
u = numpy.random.randint(10, 20, E)
p = numpy.random.rand(P)
d_mu = 100 * numpy.ones(P) # Not used
d_Sigma = 0.01 * numpy.eye(P) # Not used
m = 10 # Num samples
A = [self.get_A(i, E, P) for i in range(C)]
# Create optimization variables.
x = [NonNegative(E) for i in range(C)]
y = NonNegative(P)
# Create second stage problem.
capacity = [A[i] * y <= x[i] for i in range(C)]
d = RandomVariable(pymc.Lognormal(name="d", mu=0, tau=1, size=P))
p2 = Problem(Minimize(-y.T * p), [y <= d] + capacity)
Q = partial_optimize(p2, [y], [x[0], x[1]])
# Create and solve first stage problem.
p1 = Problem(Minimize(expectation(Q, m)), [sum(x) <= u])
p1.solve()
self.assert_feas(p1)
def _lognormal_concentration_prior(name, stated_concentration, uncertainty,
unit):
"""Define a pymc prior for a concentration, using micromolar units
:rtype : pymc.Lognormal
"""
return pymc.Lognormal(
name,
mu=log(stated_concentration / unit),
tau=1.0 / log(1.0 + (uncertainty / stated_concentration)**2),
value=stated_concentration / unit)
def make_model():
import cPickle as pickle
with open('reaction_kinetics_data.pickle', 'rb') as fd:
data = pickle.load(fd)
y_obs = data['y_obs']
# The priors for the reaction rates:
k1 = pymc.Lognormal('k1', mu=2, tau=1./(10. ** 2), value=5.)
k2 = pymc.Lognormal('k2', mu=4, tau=1./(10. ** 2), value=5.)
# The noise term
#sigma = pymc.Uninformative('sigma', value=1.)
sigma = pymc.Exponential('sigma', beta=1.)
# The forward model
re_solver = ReactionKineticsSolver()
@pymc.deterministic
def model_output(value=None, k1=k1, k2=k2):
return re_solver(k1, k2)
# The likelihood term
@pymc.stochastic(observed=True)
def output(value=y_obs, mod_out=model_output, sigma=sigma, gamma=1.):
return gamma * pymc.normal_like(y_obs, mu=mod_out, tau=1/sigma ** 2)
return locals()
def make_model():
#c = pymc.Container([pymc.Lognormal('x', mu=math.log(1.), tau=1.),
# pymc.Lognormal('z', mu=math.log(2.), tau=3.)])
#x = pymc.Exponential('x', beta=0.1)
x = pymc.Lognormal('x',
mu=np.array([math.log(1.), math.log(2.)]),
tau=np.array([1., 3.]))
@pymc.stochastic(observed=True)
def y(value=0.01, x=x):
return pymc.lognormal_like(value, mu=x[0], tau=1.)
return locals()
def test_nested_initvals(self):
# See issue #5168
with pm.Model() as pmodel:
one = pm.LogNormal("one",
mu=np.log(1),
sigma=1e-5,
initval="prior")
two = pm.Lognormal("two",
mu=np.log(one * 2),
sigma=1e-5,
initval="prior")
three = pm.LogNormal("three",
mu=np.log(two * 2),
sigma=1e-5,
initval="prior")
four = pm.LogNormal("four",
mu=np.log(three * 2),
sigma=1e-5,
initval="prior")
five = pm.LogNormal("five",
mu=np.log(four * 2),
sigma=1e-5,
initval="prior")
six = pm.LogNormal("six",
mu=np.log(five * 2),
sigma=1e-5,
initval="prior")
ip_vals = list(
make_initial_point_fn(model=pmodel,
return_transformed=True)(0).values())
assert np.allclose(np.exp(ip_vals), [1, 2, 4, 8, 16, 32], rtol=1e-3)
ip_vals = list(
make_initial_point_fn(model=pmodel,
return_transformed=False)(0).values())
assert np.allclose(ip_vals, [1, 2, 4, 8, 16, 32], rtol=1e-3)
pmodel.initial_values[four] = 1
ip_vals = list(
make_initial_point_fn(model=pmodel,
return_transformed=True)(0).values())
assert np.allclose(np.exp(ip_vals), [1, 2, 4, 1, 2, 4], rtol=1e-3)
ip_vals = list(
make_initial_point_fn(model=pmodel,
return_transformed=False)(0).values())
assert np.allclose(ip_vals, [1, 2, 4, 1, 2, 4], rtol=1e-3)
def __init__(self, name, stated_concentration, uncertainty_percent):
"""
:param name: str
:param stated_concentration: float, mM
:param uncertainty: float, 0 < uncertainty < 1
"""
m = stated_concentration
uncertainty = stated_concentration * uncertainty_percent
v = uncertainty**2
model = pymc.Lognormal(name,
mu=numpy.log(m / numpy.sqrt(1 + (v / (m**2)))),
tau=1.0 / numpy.log(1 + (v / (m**2))),
value=m)
setattr(self, name, model)
fillings.append(row.filling)
dos_sub = row.data['dos_sub'][1][0] + row.data['dos_sub'][1][1]
dos_sub_energy = row.data['dos_sub'][0]
dos_sub = interpolate_nrg(dos_sub, dos_sub_energy, energy)
dos_ds.append(dos_sub)
dos_ads = row.data['dos_ads'][1][0] + row.data['dos_ads'][1][1]
dos_ads_energy = row.data['dos_ads'][0]
dos_ads = interpolate_nrg(dos_ads, dos_ads_energy, energy)
dos_adss.append(dos_ads)
# priors
dE_0 = pm.Normal('dE_0', -3.25, 1, value=-3.25)
eps_a = pm.Normal('eps_a', -5.0, 1, value=-5.0)
delta_0 = pm.Lognormal('delta_0', 1, 0.25, value=1.0)
alpha = pm.Uniform('alpha', 0, 1.0, value=0.036)
beta = pm.Lognormal('beta', 2, 1, value=2.1)
var_1 = pm.InverseGamma('var_1', 2.0, 0.05, value=0.05)
var_2 = pm.InverseGamma('var_2', 2.0, 0.1, value=0.1)
lamb = .01
@pm.stochastic(observed=True)
def custom_stochastic(eps_a=eps_a,
beta=beta,
delta_0=delta_0,
alpha=alpha,
dE_0=dE_0,
def test_dc_power(self):
# Load problem data.
fp = "pf_dc/pf_dc.mat"
data = scipy.io.loadmat(fp)
A = data.get("A")
n, E = A.shape
gen_idxes = data.get("gen_idxes")
wind_idxes = data.get("wind_idxes")
load_idxes = data.get("load_idxes")
num_gens = gen_idxes.size
num_winds = wind_idxes.size
num_loads = load_idxes.size
gen_idxes = gen_idxes.reshape(
num_gens) - 1 # "-1" to switch from Matlab to Python indexing
wind_idxes = wind_idxes.reshape(num_winds) - 1
load_idxes = load_idxes.reshape(num_loads) - 1
c_g = data.get("c_g")
temp = c_g[0]
c_g[0] = c_g[1]
c_g[1] = temp
c_w = data.get("c_w")
p = data.get("p").reshape(n)
p_orig = p
u_lines = 1 # Note: depending on the choice of this
# (and the realizations of p_w below, the
# problem may or may not be feasible, so be
# careful
u_gens = 1
m = 100 # Num samples
# Create optimization variables.
p_g1, p_g2 = NonNegative(), NonNegative()
z = NonNegative(num_winds)
p_lines = Variable(E)
p_w = RandomVariable(
pymc.Lognormal(name="p_w", mu=1, tau=1, size=num_winds))
# Create second stage problem.
p_g = vstack(p_g1, p_g2)
p = vstack(p_g1, p_g2, p[load_idxes[:-1]], p_w - z, p[load_idxes[-1]])
p2 = Problem(Minimize(p_g.T * c_g + z.T * c_w), [
A * p_lines == p, p_g <= u_gens, z <= p_w,
abs(p_lines) <= u_lines
])
Q = partial_optimize(p2, [p_g2, z, p_lines], [p_g1])
# Create and solve first stage problem.
p1 = Problem(Minimize(expectation(Q, m)))
p1.solve()
# Plot results.
B_binary = data.get("B_binary")
coords = data.get("coords")
coords[0, 0] += 0.1 # Drawing was getting clipped in Python...
# Draw edges between vertices.
fig = pyplot.figure()
for i in range(n - 1):
for j in range(i + 1, n):
if B_binary[i, j] == 1:
pyplot.plot((coords[i, 0], coords[j, 0]),
(coords[i, 1], coords[j, 1]), '-k')
# Draw symbols and power generation/consumption for each vertex.
lognorm_mean = math.exp(1 + pow(1, 2) / 2.0)
fs = 16
shift_x = 0
shift_y = 0.125
for i in range(n):
if i in gen_idxes:
pyplot.plot(coords[i, 0],
coords[i, 1],
color="crimson",
marker="s",
markersize=12)
if i == 0:
pyplot.text(coords[i, 0] + shift_x,
coords[i, 1] + shift_y,
"{0:.2f}".format(p_g1.value),
fontsize=fs)
else:
pyplot.text(coords[i, 0] + shift_x,
coords[i, 1] + shift_y,
"sec. stg.",
fontsize=fs)
elif i in wind_idxes:
pyplot.plot(coords[i, 0],
coords[i, 1],
color="blue",
marker="s",
markersize=12)
pyplot.text(coords[i, 0] + shift_x,
coords[i, 1] + shift_y,
"{0:.2f}".format(lognorm_mean),
fontsize=fs)
else:
pyplot.plot(coords[i, 0], coords[i, 1], 'ko')
pyplot.text(coords[i, 0] + shift_x,
coords[i, 1] + shift_y,
"{0:.2f}".format(p_orig[i]),
fontsize=fs)
# pyplot.axis([0, 4, 0, 3])
pyplot.axis("off")
fig.savefig("grid.png", bbox_inches="tight")
# Check results.
self.assert_feas(p1)
r = pm.Normal('r', rmu, rtau)
qcv = pm.Uniform('qcv', eps, 1., value=[0.1] * U)
qmu = pm.Uniform('qmu', eps, 2., value=[1] * U)
qtau = pm.Lambda('qtau', lambda cv=qcv, mu=qmu: (cv * mu)**-2)
q = pm.Normal('q', qmu, qtau)
# No catch observation model -- assumed known with no error
rem = pm.Lambda('rem', lambda C=CAT, K=K: C / K)
# Biomass process model
b0_mu = pm.Uniform('b0_mu', b0x / 2., 1.25, value=b0x)
bcv = pm.Uniform('bcv', eps, 1., value=[0.1] * U)
btau = pm.Lambda('btau', lambda cv=bcv, mu=b0_mu: (cv * mu)**-2)
b[0, :] = pm.Lognormal('b0', mu=b0_mu, tau=btau, value=b_inits[0, :])
for j in range(U):
for i in range(1, N):
bmean = pm.Lambda("bmean",
lambda B=b[i - 1, j], R=r[j], C=rem[i - 1, j], eps=
eps: np.log(max(B + R * B * (1. - B) - C, eps)))
b[i, j] = pm.Lognormal('b%i' % i,
mu=bmean,
tau=btau[j],
value=b_inits[i, j])
# Biomass observation model
# require a fall / spring surveys correction
# spring surveys from 1998 to 2003
# want B to represent the total biomass available in fishing year y
# when surveys are conducted in fall, Btot(t) = Bsurvey(t) + removals(t)
def make_pymc_model():
# data
madata = 1
# parameters
cs = pymc.Normal('CS', mu=0., tau=1., plot=False)
m = pymc.Normal('M', mu=mmean, tau=1./mstd**2, plot=False)
Sre = pymc.Weibull('Sre', alpha=wblc, beta=wblscale, plot=False)
Na = pymc.Lognormal('Na', mu=logNamean, tau=1./logNastd**2, plot=False)
a0 = pymc.Normal('A0', mu=a0mean, tau=1./a0std**2, plot=True)
#transformed parameters
@pymc.deterministic(name='C', plot=False)
def C(cs=cs, m=m):
um = (m-mmean)/mstd
uLogC = -np.sqrt(rolnR**2)*um-np.sqrt(1-rolnR**2)*cs
Cout = np.exp(logCmean+uLogC*logCstd)
return Cout
@pymc.deterministic(name='Kappa', plot=False)
def kappa(C=C, Sre=Sre, m=m, Na=Na):
kout = C*(Sre**m)*(G**m)*(np.pi**(m/2.))*Na
return kout
aarray = np.empty(life+1, dtype=object)
aarray[0] = a0
for i in np.arange(1,life+1):
@pymc.deterministic(name='A{}'.format(i), plot=True)
def ai(kappa=kappa, m=m, ap=aarray[i-1]):
# aiout = ap+1e3*kappa*(ap*1e-3)**(m/2.)
if m==2:
aiout = ap*np.exp(kappa*1.)
else:
tmp = 1.0-m/2.
if ap<=0: ap=1e-12
diff = kappa*1.*tmp+ap**tmp
if diff>=0:
aiout = diff**(1./tmp)
else:
aiout = acrit
if aiout>acrit:
aiout = acrit
return aiout
aarray[i] = ai
# observable variable
mivalue = madata
if mivalue is None:
obsvalue = False
mivalue = 0
else:
obsvalue = True
@pymc.stochastic(name='M{}'.format(i), plot=False, dtype=float, observed=obsvalue)
def Mi(value=mivalue, ai=aarray[3]):
def logp(value, ai):
pod = 1.-stats.norm.cdf((np.log(ai)-lmd)/beta)
pinrange = stats.norm.cdf(2.0619, loc=ai, scale=sigmae)-\
stats.norm.cdf(1.8243, loc=ai, scale=sigmae)
if value == 0:
p = (1.-pod)+pod*(1.-pinrange)
return np.log(p)
else:
return np.log(pod*pinrange)
def random(ai):
pod = 1.-stats.norm.cdf((np.log(ai)-lmd)/beta)
pinrange = stats.norm.cdf(2.0619, loc=ai, scale=sigmae)-\
stats.norm.cdf(1.8243, loc=ai, scale=sigmae)
if np.random.rand()<=pod:
return stats.bernoulli.rvs(p=pinrange,size=1)
else:
return 0
return locals()
inv.mmin, inv.mmax = [], []
for name, lower, upper, initial, sigma, dist in zip(m_name, m_min, m_max,
m_init, sigmam, pdist):
sigma = sigma / 2
if upper != lower:
logger.debug(
'Sample {} with a {} distribution, and inititial value of {} and an uncertainty of {}'
.format(name, dist, initial, sigma))
if dist is 'Gaus':
sigma = sigma / 2
p = pymc.Normal(name, mu=initial, tau=1. / sigma**2, value=initial)
elif dist is 'Logn':
frac = (sigma * 2) / 5
p = pymc.Lognormal(name,
mu=math.log(initial),
tau=1. / (0.125 * frac)**2)
else:
p = pymc.Uniform(name, lower, upper, value=initial)
inv.Sampled.append(name)
inv.Priors.append(p)
inv.mu.append(initial)
inv.tau.append(sigma)
inv.mmin.append(lower)
inv.mmax.append(upper)
elif upper == lower:
logger.debug('{} has a sigma null. Not sampled'.format(name))
inv.Fixed.append(name)
import pymc as pm
import numpy as np
import scipy.special as ss
"""
dd as dirichlet_distribution
dp as dirichilet_processs
"""
DD_PRIOR_MEAN = 10.
DD_PRIOR_STD = 1.0
DD_PRIOR_CORRELATION = 0.5
MAX_DIMENSION = 6
dp_prior = pm.Lognormal('dp_prior_mean', mu=0, tau=4)
dd_prior_mean = pm.Lognormal('dd_prior_mean', mu=3, tau=4)
dd_prior = {}
m_list = {}
cov_list = {}
for i in range(2, MAX_DIMENSION + 1):
m_list[i] = np.array([dd_prior_mean] * i)
cov_list[i] = np.array(
[[DD_PRIOR_STD * DD_PRIOR_STD * DD_PRIOR_CORRELATION] * i] * i)
for j in range(i):
cov_list[i][j][j] = DD_PRIOR_STD * DD_PRIOR_STD
@pm.stochastic
def dirichlet_distribution_prior2(value=np.array([DD_PRIOR_MEAN] * 2)):
Created on Thu Aug 31 22:46:49 2017
@author: Edward Coen
"""
import pymc as pm
import cv2
import numpy as np
import scipy.stats as st
ITER_NUM = 10
PRIOR_MEAN = 10
PRIOR_STD = 1
PRIOR_CORRELATION = 0.0
N_DIMENSION = 2
prior_mean = pm.Lognormal('prior_mean', mu=0, tau=4)
PRIOR_COV = np.array(
[[PRIOR_STD * PRIOR_STD * PRIOR_CORRELATION] * N_DIMENSION] * N_DIMENSION)
for i in range(N_DIMENSION):
PRIOR_COV[i][i] = PRIOR_STD * PRIOR_STD
proportion_array = np.array([0.9])
for i in range(ITER_NUM):
@pm.stochastic
def dirichlet_prior(value=np.array([PRIOR_MEAN] * N_DIMENSION)):
if np.any(value <= 0):
return -np.inf
return pm.distributions.mv_normal_cov_like(value,
mu=np.array([prior_mean] *
N_DIMENSION),
def make_model(Pstated,
dPstated,
Lstated,
dLstated,
top_complex_fluorescence=None,
top_ligand_fluorescence=None,
bottom_complex_fluorescence=None,
bottom_ligand_fluorescence=None,
DG_prior='uniform',
concentration_priors='lognormal',
use_primary_inner_filter_correction=True,
use_secondary_inner_filter_correction=True,
assay_volume=100e-6,
well_area=0.1586,
epsilon_ex=None,
depsilon_ex=None,
epsilon_em=None,
depsilon_em=None,
ligand_ex_absorbance=None,
ligand_em_absorbance=None,
link_top_and_bottom_sigma=True):
"""
Build a PyMC model for an assay that consists of N wells of protein:ligand at various concentrations and an additional N wells of ligand in buffer, with the ligand at the same concentrations as the corresponding protein:ligand wells.
Parameters
----------
Pstated : numpy.array of N values
Stated protein concentrations for all protein:ligand wells of assay. Units of molarity.
dPstated : numpy.array of N values
Absolute uncertainty in stated protein concentrations for all wells of assay. Units of molarity.
Uncertainties currently cannot be zero.
Lstated : numpy.array of N values
Stated ligand concentrations for all protein:ligand and ligand wells of assay, which must be the same with and without protein. Units of molarity.
dLstated : numpy.array of N values
Absolute uncertainty in stated protein concentrations for all wells of assay. Units of molarity.
Uncertainties currently cannot be zero
top_complex_fluorecence : numpy.array of N values, optional, default=None
Fluorescence intensity (top) for protein:ligand mixture.
top_ligand_fluorescence : numpy.array of N values, optional, default=None
Fluorescence intensity (top) for ligand control.
bottom_complex_fluorescence: numpy.array of N values, optional, default=None
Fluorescence intensity (bottom) for protein:ligand mixture.
bottom_ligand_fluorescence : numpy.array of N values, optional, default=None
Fluorescence intensity (bottom) for ligand control.
DG_prior : str, optional, default='uniform'
Prior to use for reduced free energy of binding (DG): 'uniform' (uniform over reasonable range), or 'chembl' (ChEMBL-inspired distribution); default: 'uniform'
concentration_priors : str, optional, default='lognormal'
Prior to use for protein and ligand concentrations. Available options are ['lognormal', 'normal'].
use_primary_inner_filter_correction : bool, optional, default=True
If true, will infer ligand extinction coefficient epsilon and apply primary inner filter correction to attenuate excitation light.
use_secondary_inner_filter_correction : bool, optional, default=True
If true, will infer ligand extinction coefficient epsilon and apply secondary inner filter correction to attenuate excitation light.
assay_volume : float, optional, default=100e-6
Assay volume. Units of L. Default 100 uL.
well_area : float, optional, default=0.1586
Well area. Units of cm^2. Default 0.1586 cm^2, for half-area plate.
epsilon_ex, depsilon_ex : float, optional, default=None
Orthogonal measurement of ligand extinction coefficient at excitation wavelength (and uncertainty). If None, will use a uniform prior.
epsilon_em, depsilon_em : float, optional, default=None
Orthogonal measurement of ligand extinction coefficient at excitation wavelength (and uncertainty). If None, will use a uniform prior.
ligand_ex_absorbance : np.array of N values, optional, default=None
Ligand absorbance measurement for excitation wavelength.
ligand_em_absorbance : np.array of N values, optional, default=None
Ligand absorbance measurement for emission wavelength.
link_top_and_bottom_sigma : bool, optional, default=True
If True, will link top and bottom fluorescence uncertainty sigma.
Returns
-------
pymc_model : dict
A dict mapping variable names to onbjects that can be used as a PyMC model object.
Examples
--------
Create a simple model
>>> N = 12 # 12 wells per series of protein:ligand or ligand alone
>>> Pstated = np.ones([N], np.float64) * 1e-6
>>> Lstated = 20.0e-6 / np.array([10**(float(i)/2.0) for i in range(N)])
>>> dPstated = 0.10 * Pstated
>>> dLstated = 0.08 * Lstated
>>> top_complex_fluorescence = np.array([ 689., 683., 664., 588., 207., 80., 28., 17., 10., 11., 10., 10.], np.float32)
>>> top_ligand_fluorescence = np.array([ 174., 115., 57., 20., 7., 6., 6., 6., 6., 7., 6., 7.], np.float32)
>>> from pymcmodels import make_model
>>> pymc_model = make_model(Pstated, dPstated, Lstated, dLstated, top_complex_fluorescence=top_complex_fluorescence, top_ligand_fluorescence=top_ligand_fluorescence)
"""
# Compute path length.
path_length = assay_volume * 1000 / well_area # cm, needed for inner filter effect corrections
# Compute number of samples.
N = len(Lstated)
# Check input.
# TODO: Check fluorescence and absorbance measurements for correct dimensions.
if (len(Pstated) != N):
raise Exception('len(Pstated) [%d] must equal len(Lstated) [%d].' %
(len(Pstated), len(Lstated)))
if (len(dPstated) != N):
raise Exception('len(dPstated) [%d] must equal len(Lstated) [%d].' %
(len(dPstated), len(Lstated)))
if (len(dLstated) != N):
raise Exception('len(dLstated) [%d] must equal len(Lstated) [%d].' %
(len(dLstated), len(Lstated)))
# Note whether we have top or bottom fluorescence measurements.
top_fluorescence = (top_complex_fluorescence is not None) or (
top_ligand_fluorescence is not None
) # True if any top fluorescence measurements provided
bottom_fluorescence = (bottom_complex_fluorescence is not None) or (
bottom_ligand_fluorescence is not None
) # True if any bottom fluorescence measurements provided
# Create an empty dict to hold the model.
model = dict()
# Prior on binding free energies.
if DG_prior == 'uniform':
DeltaG = pymc.Uniform(
'DeltaG', lower=DG_min,
upper=DG_max) # binding free energy (kT), uniform over huge range
elif DG_prior == 'chembl':
DeltaG = pymc.Normal(
'DeltaG', mu=0, tau=1. / (12.5**2)
) # binding free energy (kT), using a Gaussian prior inspured by ChEMBL
else:
raise Exception(
"DG_prior = '%s' unknown. Must be one of 'uniform' or 'chembl'." %
DG_prior)
# Add to model.
model['DeltaG'] = DeltaG
# Create priors on true concentrations of protein and ligand.
if concentration_priors == 'lognormal':
Ptrue = pymc.Lognormal(
'Ptrue',
mu=np.log(Pstated**2 / np.sqrt(dPstated**2 + Pstated**2)),
tau=np.sqrt(np.log(1.0 + (dPstated / Pstated)**2))**(
-2)) # protein concentration (M)
Ltrue = pymc.Lognormal(
'Ltrue',
mu=np.log(Lstated**2 / np.sqrt(dLstated**2 + Lstated**2)),
tau=np.sqrt(np.log(1.0 + (dLstated / Lstated)**2))**(
-2)) # ligand concentration (M)
Ltrue_control = pymc.Lognormal(
'Ltrue_control',
mu=np.log(Lstated**2 / np.sqrt(dLstated**2 + Lstated**2)),
tau=np.sqrt(np.log(1.0 + (dLstated / Lstated)**2))**(
-2)) # ligand concentration (M)
elif concentration_priors == 'gaussian':
# Warning: These priors could lead to negative concentrations.
Ptrue = pymc.Normal('Ptrue', mu=Pstated,
tau=dPstated**(-2)) # protein concentration (M)
Ltrue = pymc.Normal('Ltrue', mu=Lstated,
tau=dLstated**(-2)) # ligand concentration (M)
Ltrue_control = pymc.Normal(
'Ltrue_control', mu=Lstated,
tau=dLstated**(-2)) # ligand concentration (M)
else:
raise Exception(
"concentration_priors = '%s' unknown. Must be one of ['lognormal', 'normal']."
% concentration_priors)
# Add to model.
model['Ptrue'] = Ptrue
model['Ltrue'] = Ltrue
model['Ltrue_control'] = Ltrue_control
# extinction coefficient
if use_primary_inner_filter_correction:
if epsilon_ex:
model['epsilon_ex'] = pymc.Lognormal(
'epsilon_ex',
mu=np.log(epsilon_ex**2 /
np.sqrt(depsilon_ex**2 + epsilon_ex**2)),
tau=np.sqrt(np.log(1.0 + (depsilon_ex / epsilon_ex)**2))**
(-2)) # prior is centered on measured extinction coefficient
else:
model['epsilon_ex'] = pymc.Uniform(
'epsilon_ex', lower=0.0, upper=1000e3, value=70000.0
) # extinction coefficient or molar absorptivity for ligand, units of 1/M/cm
if use_secondary_inner_filter_correction:
if epsilon_em:
model['epsilon_em'] = pymc.Lognormal(
'epsilon_em',
mu=np.log(epsilon_em**2 /
np.sqrt(depsilon_em**2 + epsilon_em**2)),
tau=np.sqrt(np.log(1.0 + (depsilon_em / epsilon_em)**2))**
(-2)) # prior is centered on measured extinction coefficient
else:
model['epsilon_em'] = pymc.Uniform(
'epsilon_em', lower=0.0, upper=1000e3, value=0.0
) # extinction coefficient or molar absorptivity for ligand, units of 1/M/cm
# Min and max observed fluorescence.
Fmax = 0.0
Fmin = 1e6
if top_complex_fluorescence is not None:
Fmax = max(Fmax, top_complex_fluorescence.max())
Fmin = min(Fmin, top_complex_fluorescence.min())
if top_ligand_fluorescence is not None:
Fmax = max(Fmax, top_ligand_fluorescence.max())
Fmin = min(Fmin, top_ligand_fluorescence.min())
if bottom_complex_fluorescence is not None:
Fmax = max(Fmax, bottom_complex_fluorescence.max())
Fmin = min(Fmin, bottom_complex_fluorescence.min())
if bottom_ligand_fluorescence is not None:
Fmax = max(Fmax, bottom_ligand_fluorescence.max())
Fmin = min(Fmin, bottom_ligand_fluorescence.min())
# Compute initial guesses for fluorescence quantum yield quantities.
F_plate_guess = Fmin
F_buffer_guess = Fmin / path_length
F_L_guess = (Fmax - Fmin) / Lstated.max()
F_P_guess = 0.0
F_P_guess = Fmin / Pstated.min()
F_PL_guess = (Fmax - Fmin) / min(Pstated.max(), Lstated.max())
# Priors on fluorescence intensities of complexes (later divided by a factor of Pstated for scale).
model['F_plate'] = pymc.Uniform('F_plate',
lower=0.0,
upper=Fmax,
value=F_plate_guess) # plate fluorescence
model['F_buffer'] = pymc.Uniform(
'F_buffer', lower=0.0, upper=Fmax / path_length,
value=F_buffer_guess) # buffer fluorescence
model['F_PL'] = pymc.Uniform('F_PL',
lower=0.0,
upper=2 * Fmax /
min(Pstated.max(), Lstated.max()),
value=F_PL_guess) # complex fluorescence
model['F_P'] = pymc.Uniform('F_P',
lower=0.0,
upper=2 * (Fmax / Pstated).max(),
value=F_P_guess) # protein fluorescence
model['F_L'] = pymc.Uniform('F_L',
lower=0.0,
upper=2 * (Fmax / Lstated).max(),
value=F_L_guess) # ligand fluorescence
# Unknown experimental measurement error.
if top_fluorescence:
model['log_sigma_top'] = pymc.Uniform('log_sigma_top',
lower=-10,
upper=np.log(Fmax),
value=np.log(5))
model['sigma_top'] = pymc.Lambda(
'sigma_top',
lambda log_sigma=model['log_sigma_top']: np.exp(log_sigma))
model['precision_top'] = pymc.Lambda(
'precision_top',
lambda log_sigma=model['log_sigma_top']: np.exp(-2 * log_sigma))
if bottom_fluorescence:
if top_fluorescence and bottom_fluorescence and link_top_and_bottom_sigma:
# Use the same log_sigma for top and bottom fluorescence
model['log_sigma_bottom'] = pymc.Lambda(
'log_sigma_bottom',
lambda log_sigma_top=model['log_sigma_top']: log_sigma_top)
else:
model['log_sigma_bottom'] = pymc.Uniform('log_sigma_bottom',
lower=-10,
upper=np.log(Fmax),
value=np.log(5))
model['sigma_bottom'] = pymc.Lambda(
'sigma_bottom',
lambda log_sigma=model['log_sigma_bottom']: np.exp(log_sigma))
model['precision_bottom'] = pymc.Lambda(
'precision_bottom',
lambda log_sigma=model['log_sigma_bottom']: np.exp(-2 * log_sigma))
if top_fluorescence and bottom_fluorescence:
# Gain that attenuates bottom fluorescence relative to top.
# TODO: Replace this with plate absorbance?
log_gain_guess = -np.log(
(top_complex_fluorescence.max() - top_complex_fluorescence.min()) /
(bottom_complex_fluorescence.max() -
bottom_complex_fluorescence.min()))
model['log_gain_bottom'] = pymc.Uniform(
'log_gain_bottom', lower=-6.0, upper=6.0, value=log_gain_guess
) # plate material absorbance at emission wavelength
model['gain_bottom'] = pymc.Lambda(
'gain_bottom',
lambda log_gain_bottom=model['log_gain_bottom']: np.exp(
log_gain_bottom))
elif (not top_fluorescence) and bottom_fluorescence:
model['log_gain_bottom'] = 0.0 # no gain
model['gain_bottom'] = pymc.Lambda(
'gain_bottom',
lambda log_gain_bottom=model['log_gain_bottom']: np.exp(
log_gain_bottom))
if top_fluorescence:
model['log_sigma_abs'] = pymc.Uniform('log_sigma_abs',
lower=-10,
upper=0,
value=np.log(0.01))
model['sigma_abs'] = pymc.Lambda(
'sigma_abs',
lambda log_sigma=model['log_sigma_abs']: np.exp(log_sigma))
model['precision_abs'] = pymc.Lambda(
'precision_abs',
lambda log_sigma=model['log_sigma_abs']: np.exp(-2 * log_sigma))
# Fluorescence model.
from assaytools.bindingmodels import TwoComponentBindingModel
if hasattr(model, 'epsilon_ex'):
epsilon_ex = model['epsilon_ex']
else:
epsilon_ex = 0.0
if hasattr(model, 'epsilon_em'):
epsilon_em = model['epsilon_em']
else:
epsilon_em = 0.0
if top_complex_fluorescence is not None:
@pymc.deterministic
def top_complex_fluorescence_model(F_plate=model['F_plate'],
F_buffer=model['F_buffer'],
F_PL=model['F_PL'],
F_P=model['F_P'],
F_L=model['F_L'],
Ptrue=Ptrue,
Ltrue=Ltrue,
DeltaG=DeltaG,
epsilon_ex=epsilon_ex,
epsilon_em=epsilon_em):
[P_i, L_i,
PL_i] = TwoComponentBindingModel.equilibrium_concentrations(
DeltaG, Ptrue[:], Ltrue[:])
IF_i = inner_filter_effect_attenuation(epsilon_ex,
epsilon_em,
path_length,
L_i,
geometry='top')
IF_i_plate = np.exp(
-(epsilon_ex + epsilon_em) * path_length *
L_i) # inner filter effect applied only to plate
Fmodel_i = IF_i[:] * (
F_PL * PL_i + F_L * L_i + F_P * P_i +
F_buffer * path_length) + IF_i_plate * F_plate
return Fmodel_i
# Add to model.
model[
'top_complex_fluorescence_model'] = top_complex_fluorescence_model
model['top_complex_fluorescence'] = pymc.Normal(
'top_complex_fluorescence',
mu=model['top_complex_fluorescence_model'],
tau=model['precision_top'],
size=[N],
observed=True,
value=top_complex_fluorescence) # observed data
if top_ligand_fluorescence is not None:
@pymc.deterministic
def top_ligand_fluorescence_model(F_plate=model['F_plate'],
F_buffer=model['F_buffer'],
F_L=model['F_L'],
Ltrue=Ltrue,
epsilon_ex=epsilon_ex,
epsilon_em=epsilon_em):
IF_i = inner_filter_effect_attenuation(epsilon_ex,
epsilon_em,
path_length,
Ltrue,
geometry='top')
IF_i_plate = np.exp(
-(epsilon_ex + epsilon_em) * path_length *
Ltrue) # inner filter effect applied only to plate
Fmodel_i = IF_i[:] * (
F_L * Ltrue + F_buffer * path_length) + IF_i_plate * F_plate
return Fmodel_i
# Add to model.
model['top_ligand_fluorescence_model'] = top_ligand_fluorescence_model
model['top_ligand_fluorescence'] = pymc.Normal(
'top_ligand_fluorescence',
mu=model['top_ligand_fluorescence_model'],
tau=model['precision_top'],
size=[N],
observed=True,
value=top_ligand_fluorescence) # observed data
if bottom_complex_fluorescence is not None:
@pymc.deterministic
def bottom_complex_fluorescence_model(
F_plate=model['F_plate'],
F_buffer=model['F_buffer'],
F_PL=model['F_PL'],
F_P=model['F_P'],
F_L=model['F_L'],
Ptrue=Ptrue,
Ltrue=Ltrue,
DeltaG=DeltaG,
epsilon_ex=epsilon_ex,
epsilon_em=epsilon_em,
log_gain_bottom=model['log_gain_bottom']):
[P_i, L_i,
PL_i] = TwoComponentBindingModel.equilibrium_concentrations(
DeltaG, Ptrue[:], Ltrue[:])
IF_i = inner_filter_effect_attenuation(epsilon_ex,
epsilon_em,
path_length,
L_i,
geometry='bottom')
IF_i_plate = np.exp(
-epsilon_ex * path_length *
L_i) # inner filter effect applied only to plate
Fmodel_i = IF_i[:] * (F_PL * PL_i + F_L * L_i + F_P * P_i +
F_buffer * path_length) * np.exp(
log_gain_bottom) + IF_i_plate * F_plate
return Fmodel_i
# Add to model.
model[
'bottom_complex_fluorescence_model'] = bottom_complex_fluorescence_model
model['bottom_complex_fluorescence'] = pymc.Normal(
'bottom_complex_fluorescence',
mu=model['bottom_complex_fluorescence_model'],
tau=model['precision_bottom'],
size=[N],
observed=True,
value=bottom_complex_fluorescence) # observed data
if bottom_ligand_fluorescence is not None:
@pymc.deterministic
def bottom_ligand_fluorescence_model(
F_plate=model['F_plate'],
F_buffer=model['F_buffer'],
F_PL=model['F_PL'],
F_P=model['F_P'],
F_L=model['F_L'],
Ltrue=Ltrue,
epsilon_ex=epsilon_ex,
epsilon_em=epsilon_em,
log_gain_bottom=model['log_gain_bottom']):
IF_i = inner_filter_effect_attenuation(epsilon_ex,
epsilon_em,
path_length,
Ltrue,
geometry='bottom')
IF_i_plate = np.exp(
-epsilon_ex * path_length *
Ltrue) # inner filter effect applied only to plate
Fmodel_i = IF_i[:] * (F_L * Ltrue +
F_buffer * path_length) * np.exp(
log_gain_bottom) + IF_i_plate * F_plate
return Fmodel_i
# Add to model.
model[
'bottom_ligand_fluorescence_model'] = bottom_ligand_fluorescence_model
model['bottom_ligand_fluorescence'] = pymc.Normal(
'bottom_ligand_fluorescence',
mu=model['bottom_ligand_fluorescence_model'],
tau=model['precision_bottom'],
size=[N],
observed=True,
value=bottom_ligand_fluorescence) # observed data
if ligand_ex_absorbance is not None:
model['plate_abs_ex'] = pymc.Uniform('plate_abs_ex',
lower=0.0,
upper=1.0,
value=ligand_ex_absorbance.min())
@pymc.deterministic
def ligand_ex_absorbance_model(Ltrue=Ltrue,
epsilon_ex=epsilon_ex,
plate_abs_ex=epsilon_em):
Fmodel_i = (
1.0 - np.exp(-epsilon_ex * path_length * Ltrue)) + plate_abs_ex
return Fmodel_i
# Add to model.
model['ligand_ex_absorbance_model'] = ligand_ex_absorbance_model
model['ligand_ex_absorbance'] = pymc.Normal(
'ligand_ex_absorbance',
mu=model['ligand_ex_absorbance_model'],
tau=model['precision_abs'],
size=[N],
observed=True,
value=ligand_ex_absorbance) # observed data
if ligand_em_absorbance is not None:
model['plate_abs_em'] = pymc.Uniform('plate_abs_em',
lower=0.0,
upper=1.0,
value=ligand_em_absorbance.min())
@pymc.deterministic
def ligand_em_absorbance_model(Ltrue=Ltrue,
epsilon_em=model['epsilon_em'],
plate_abs_em=model['plate_abs_em']):
Fmodel_i = (
1.0 - np.exp(-epsilon_em * path_length * Ltrue)) + plate_abs_em
return Fmodel_i
# Add to model.
model['ligand_em_absorbance_model'] = ligand_em_absorbance_model
model['ligand_em_absorbance'] = pymc.Normal(
'ligand_em_absorbance',
mu=model['ligand_em_absorbance_model'],
tau=model['precision_abs'],
size=[N],
observed=True,
value=ligand_em_absorbance) # observed data
# Promote this to a full-fledged PyMC model.
pymc_model = pymc.Model(model)
# Return the pymc model
return pymc_model
labelMatrix = generateMatrix.getAchievementDetail(isSub=True, subjectName="数学")
np.save("labelMatrix", labelMatrix)
# 得到二分矩阵的行数和列数（分别表示题目数量和学生数量）
numQuestion, numPeople = labelMatrix.shape
print(numQuestion, numPeople)
# 初始化theta，logA，b的值
theta_initial = np.zeros((NUM_THETAS, numPeople))
a_initial = np.ones((numQuestion, NUM_THETAS))
b_initial = np.zeros((numQuestion, NUM_THETAS))
# 构建参数theta，logA，b的建议分布采样, value是采样前的初始值
theta = pm.Normal("theta", mu=0, tau=1.1 ** 2, value=theta_initial)
a = pm.Lognormal("a", mu=0, tau=0.3 ** 2, value= a_initial)
b = pm.Normal("b", mu=0, tau=0.3 ** 2, value=b_initial)
@pm.deterministic # 将先验标为一个定值
def irtModel(theta=theta, a=a, b=b):
bs = np.repeat(b, numPeople, 1)
prob = 1.0 / (1.0 + np.exp(D * (bs - np.dot(a, theta))))
return prob
# 得到预测的结果，在这里irtModel代表了先验，value代表了观测值，labels是后验分布
labels = pm.Bernoulli("labels", p=irtModel, value=labelMatrix, observed=True)
mcmc = pm.MCMC([a, b, theta, labels])
def __init__(self,
experiments,
receptor,
V0,
concentration_uncertainty=0.10,
verbose=False):
"""
ARGUMENTS
experiments (list of Experiment) -
receptor (string) - name of receptor species
V0 (float) - calorimeter sample cell volume
OPTIONAL ARGUMENTS
concentration_uncertainty (float) - relative uncertainty in concentrations
"""
self.verbose = verbose
# Store temperature.
# NOTE: Right now, there can only be one.
self.temperature = experiments[0].temperature # temperature (kelvin)
self.beta = 1.0 / (kB * self.temperature
) # inverse temperature 1/(kcal/mol)
# Store copy of experiments.
self.experiments = copy.deepcopy(experiments)
if verbose: print "%d experiments" % len(self.experiments)
# Store sample cell volume.
self.V0 = V0
# Store the name of the receptor.
self.receptor = receptor
if verbose:
print "species '%s' will be treated as receptor" % self.receptor
# Make a list of names of all molecular species.
self.species = set() # all molecular species
for experiment in experiments:
self.species.update(experiment.sample_cell_concentrations.keys())
self.species.update(experiment.syringe_concentrations.keys())
if verbose: print "species: ", self.species
# Make a list of all ligands.
self.ligands = copy.deepcopy(self.species)
self.ligands.remove(receptor)
if verbose: print "ligands: ", self.ligands
# Create a list of all stochastics.
self.stochastics = list()
# Create a prior for thermodynamic parameters of binding for each ligand-receptor interaction.
DeltaG_min = -40. # (kcal/mol)
DeltaG_max = +40. # (kcal/mol)
DeltaH_min = -100. # (kcal/mol)
DeltaH_max = +100. # (kcal/mol)
self.thermodynamic_parameters = dict()
for ligand in self.ligands:
name = "DeltaG of %s * %s" % (self.receptor, ligand)
x = pymc.Uniform(name,
lower=DeltaG_min,
upper=DeltaG_max,
value=0.0)
self.thermodynamic_parameters[name] = x
self.stochastics.append(x)
name = "DeltaH of %s * %s" % (self.receptor, ligand)
x = pymc.Uniform(name,
lower=DeltaH_min,
upper=DeltaH_max,
value=0.0)
self.thermodynamic_parameters[name] = x
self.stochastics.append(x)
if verbose:
print "thermodynamic parameters:"
print self.thermodynamic_parameters
# DEBUG: Set initial thermodynamic parameters to literature values.
self.thermodynamic_parameters[
"DeltaG of HIV protease * acetyl pepstatin"].value = -9.0
self.thermodynamic_parameters[
"DeltaH of HIV protease * acetyl pepstatin"].value = +6.8
self.thermodynamic_parameters[
"DeltaG of HIV protease * KNI-10033"].value = -14.870
self.thermodynamic_parameters[
"DeltaH of HIV protease * KNI-10033"].value = -8.200
self.thermodynamic_parameters[
"DeltaG of HIV protease * KNI-10075"].value = -14.620
self.thermodynamic_parameters[
"DeltaH of HIV protease * KNI-10075"].value = -12.120
# Determine min and max range for log_sigma (log of instrument heat measurement error)
# TODO: This should depend on a number of factors, like integration time, heat signal, etc.?
sigma_guess = 0.0
for experiment in self.experiments:
sigma_guess += experiment.observed_injection_heats[-4:].std()
sigma_guess /= float(len(self.experiments))
log_sigma_guess = log(sigma_guess)
log_sigma_min = log_sigma_guess - 10
log_sigma_max = log_sigma_guess + 5
self.log_sigma = pymc.Uniform('log_sigma',
lower=log_sigma_min,
upper=log_sigma_max,
value=log_sigma_guess)
self.stochastics.append(self.log_sigma)
tau = pymc.Lambda(
'tau', lambda log_sigma=self.log_sigma: exp(-2.0 * log_sigma))
self.stochastics.append(tau)
# Define priors for unknowns for each experiment.
for (index, experiment) in enumerate(self.experiments):
# Number of observations
experiment.ninjections = experiment.observed_injection_heats.size
if verbose:
print "Experiment %d has %d injections" % (
index, experiment.ninjections)
# Heat of dilution / mixing
# We allow the heat of dilution/mixing to range in observed range of heats, plus a larger margin of the range of oberved heats.
max_heat = experiment.observed_injection_heats.max()
min_heat = experiment.observed_injection_heats.min()
heat_interval = max_heat - min_heat
last_heat = experiment.observed_injection_heats[
-1] # last injection heat provides a good initial guess for heat of dilution/mixing
experiment.DeltaH_0 = pymc.Uniform("DeltaH_0 for experiment %d" %
index,
lower=min_heat - heat_interval,
upper=max_heat + heat_interval,
value=last_heat)
self.stochastics.append(experiment.DeltaH_0)
# True concentrations
experiment.true_sample_cell_concentrations = dict()
for species, concentration in experiment.sample_cell_concentrations.iteritems(
):
x = pymc.Lognormal(
"initial sample cell concentration of %s in experiment %d"
% (species, index),
mu=log(concentration),
tau=1.0 / log(1.0 + concentration_uncertainty**2),
value=concentration)
experiment.true_sample_cell_concentrations[species] = x
self.stochastics.append(x)
experiment.true_syringe_concentrations = dict()
for species, concentration in experiment.syringe_concentrations.iteritems(
):
x = pymc.Lognormal(
"initial syringe concentration of %s in experiment %d" %
(species, index),
mu=log(concentration),
tau=1.0 / log(1.0 + concentration_uncertainty**2),
value=concentration)
experiment.true_syringe_concentrations[species] = x
self.stochastics.append(x)
# Add species not explicitly listed with zero concentration.
for species in self.species:
if species not in experiment.true_sample_cell_concentrations:
experiment.true_sample_cell_concentrations[species] = 0.0
if species not in experiment.true_syringe_concentrations:
experiment.true_syringe_concentrations[species] = 0.0
# True injection heats
experiment.true_injection_heats = pymc.Lambda(
"true injection heats for experiment %d" % index,
lambda experiment=experiment, sample_cell_concentrations=
experiment.true_sample_cell_concentrations,
syringe_concentrations=experiment.true_syringe_concentrations,
DeltaH_0=experiment.DeltaH_0, thermodynamic_parameters=self.
thermodynamic_parameters: self.expected_injection_heats(
experiment, sample_cell_concentrations,
syringe_concentrations, DeltaH_0, thermodynamic_parameters
))
self.stochastics.append(experiment.true_injection_heats)
# Observed injection heats
experiment.observation = pymc.Normal(
"observed injection heats for experiment %d" % index,
mu=experiment.true_injection_heats,
tau=tau,
observed=True,
value=experiment.observed_injection_heats)
self.stochastics.append(experiment.observation)
# Create sampler.
print "Creating sampler..."
mcmc = pymc.MCMC(self.stochastics, db='ram')
#db = pymc.database.pickle.load('MCMC.pickle') # DEBUG
#mcmc = pymc.MCMC(self.stochastics, db=db)
for stochastic in self.stochastics:
print stochastic
try:
mcmc.use_step_method(pymc.Metropolis, stochastic)
except:
pass
mcmc.use_step_method(
RescalingStep, {
'Ls':
self.experiments[0].
true_syringe_concentrations['acetyl pepstatin'],
'P0':
self.experiments[0].
true_sample_cell_concentrations['HIV protease'],
'DeltaH':
self.thermodynamic_parameters[
'DeltaH of HIV protease * acetyl pepstatin'],
'DeltaG':
self.thermodynamic_parameters[
'DeltaG of HIV protease * acetyl pepstatin']
}, self.beta)
mcmc.use_step_method(
RescalingStep, {
'Ls':
self.experiments[1].true_syringe_concentrations['KNI-10033'],
'P0':
self.experiments[1].
true_sample_cell_concentrations['HIV protease'],
'DeltaH':
self.
thermodynamic_parameters['DeltaH of HIV protease * KNI-10033'],
'DeltaG':
self.
thermodynamic_parameters['DeltaG of HIV protease * KNI-10033']
}, self.beta)
mcmc.use_step_method(
RescalingStep, {
'Ls':
self.experiments[2].true_syringe_concentrations['KNI-10075'],
'P0':
self.experiments[2].
true_sample_cell_concentrations['HIV protease'],
'DeltaH':
self.
thermodynamic_parameters['DeltaH of HIV protease * KNI-10075'],
'DeltaG':
self.
thermodynamic_parameters['DeltaG of HIV protease * KNI-10075']
}, self.beta)
self.mcmc = mcmc
def __init__(self, experiments, receptor, concentration_uncertainty=0.10):
"""
ARGUMENTS
experiments (list of Experiment) -
instrument Instrument that experiment was carried out in (has to be one)
receptor (string) - name of receptor species
OPTIONAL ARGUMENTS
concentration_uncertainty (float) - relative uncertainty in concentrations
"""
# Store temperature.
# NOTE: Right now, there can only be one.
self.temperature = experiments[0].temperature # temperature (kelvin)
self.beta = 1.0 / (ureg.molar_gas_constant * self.temperature
) # inverse temperature 1/(kcal/mol)
# Store copy of experiments.
self.experiments = experiments
logging.info("%d experiments" % len(self.experiments))
# Store sample cell volume.
self.V0 = self.experiments[0].cell_volume
# Store the name of the receptor.
self.receptor = receptor
logging.info("species '%s' will be treated as receptor" %
self.receptor)
# Make a list of names of all molecular species.
self.species = set() # all molecular species
for experiment in experiments:
self.species.update(experiment.cell_concentration.keys())
self.species.update(experiment.syringe_concentration.keys())
logging.info("species: %s" % self.species)
# Make a list of all ligands.
self.ligands = copy.deepcopy(self.species)
self.ligands.remove(receptor)
logging.info("ligands: %s" % self.ligands)
# Create a list of all stochastics.
self.stochastics = list()
# Create a prior for thermodynamic parameters of binding for each ligand-receptor interaction.
DeltaG_min = -40. # (kcal/mol)
DeltaG_max = +40. # (kcal/mol)
DeltaH_min = -100. # (kcal/mol)
DeltaH_max = +100. # (kcal/mol)
self.thermodynamic_parameters = dict()
for ligand in self.ligands:
name = "DeltaG of %s * %s" % (self.receptor, ligand)
x = pymc.Uniform(name,
lower=DeltaG_min,
upper=DeltaG_max,
value=0.0)
self.thermodynamic_parameters[name] = x
self.stochastics.append(x)
name = "DeltaH of %s * %s" % (self.receptor, ligand)
x = pymc.Uniform(name,
lower=DeltaH_min,
upper=DeltaH_max,
value=0.0)
self.thermodynamic_parameters[name] = x
self.stochastics.append(x)
logging.debug("thermodynamic parameters:")
logging.debug(self.thermodynamic_parameters)
# # TODO: add option to set initial thermodynamic parameters to literature values.
# self.thermodynamic_parameters["DeltaG of protein * ligand"].value = -9.0
# self.thermodynamic_parameters["DeltaH of HIV protease * acetyl pepstatin"].value = +6.8
# Determine min and max range for log_sigma (log of instrument heat measurement error)
# TODO: This should depend on a number of factors, like integration time, heat signal, etc.?
sigma_guess = 0.0
for experiment in self.experiments:
sigma_guess += experiment.observed_injection_heats[:-4].std()
sigma_guess /= float(len(self.experiments))
log_sigma_guess = log(sigma_guess /
Quantity('microcalorie')) #remove unit
log_sigma_min = log_sigma_guess - 10
log_sigma_max = log_sigma_guess + 5
self.log_sigma = pymc.Uniform('log_sigma',
lower=log_sigma_min,
upper=log_sigma_max,
value=log_sigma_guess)
self.stochastics.append(self.log_sigma)
tau = pymc.Lambda(
'tau', lambda log_sigma=self.log_sigma: exp(-2.0 * log_sigma))
self.stochastics.append(tau)
# Define priors for unknowns for each experiment.
for (index, experiment) in enumerate(self.experiments):
# Number of observations
experiment.ninjections = experiment.observed_injection_heats.size
logging.info("Experiment %d has %d injections" %
(index, experiment.ninjections))
# Heat of dilution / mixing
# We allow the heat of dilution/mixing to range in observed range of heats, plus a larger margin of the range of oberved heats.
max_heat = experiment.observed_injection_heats.max()
min_heat = experiment.observed_injection_heats.min()
heat_interval = max_heat - min_heat
last_heat = experiment.observed_injection_heats[
-1] # last injection heat provides a good initial guess for heat of dilution/mixing
experiment.DeltaH_0 = pymc.Uniform("DeltaH_0 for experiment %d" %
index,
lower=min_heat - heat_interval,
upper=max_heat + heat_interval,
value=last_heat)
self.stochastics.append(experiment.DeltaH_0)
# True concentrations
experiment.true_cell_concentration = dict()
for species, concentration in experiment.cell_concentration.iteritems(
):
x = pymc.Lognormal(
"initial sample cell concentration of %s in experiment %d"
% (species, index),
mu=log(concentration / Quantity('millimole per liter')),
tau=1.0 / log(1.0 + concentration_uncertainty**2),
value=concentration / Quantity('millimole per liter'))
experiment.true_cell_concentration[species] = x
self.stochastics.append(x)
experiment.true_syringe_concentration = dict()
for species, concentration in experiment.syringe_concentration.iteritems(
):
x = pymc.Lognormal(
"initial syringe concentration of %s in experiment %d" %
(species, index),
mu=log(concentration / Quantity('millimole per liter')),
tau=1.0 / log(1.0 + concentration_uncertainty**2),
value=concentration / Quantity('millimole per liter'))
experiment.true_syringe_concentration[species] = x
self.stochastics.append(x)
# Add species not explicitly listed with zero concentration.
for species in self.species:
if species not in experiment.true_cell_concentration:
experiment.true_cell_concentration[species] = 0.0
if species not in experiment.true_syringe_concentration:
experiment.true_syringe_concentration[species] = 0.0
# True injection heats
experiment.true_injection_heats = pymc.Lambda(
"true injection heats for experiment %d" % index,
lambda ligands=self.ligands, receptor=self.receptor, V0=self.
V0, N=experiment.ninjections, volumes=experiment.
injection_volumes, beta=self.beta, cell_concentration=
experiment.true_cell_concentration, syringe_concentration=
experiment.true_syringe_concentration, DeltaH_0=experiment.
DeltaH_0, thermodynamic_parameters=self.
thermodynamic_parameters: self.expected_injection_heats(
ligands, receptor, V0, N, volumes, beta,
cell_concentration, syringe_concentration, DeltaH_0,
thermodynamic_parameters))
self.stochastics.append(experiment.true_injection_heats)
# Observed injection heats
experiment.observation = pymc.Normal(
"observed injection heats for experiment %d" % index,
mu=experiment.true_injection_heats,
tau=tau,
observed=True,
value=experiment.observed_injection_heats)
self.stochastics.append(experiment.observation)
# Create sampler.
print("Creating sampler...")
mcmc = pymc.MCMC(self.stochastics, db='ram')
for stochastic in self.stochastics:
# print stochastic
try:
mcmc.use_step_method(pymc.Metropolis, stochastic)
except:
pass
for experiment in self.experiments:
for ligand in self.ligands:
if isinstance(experiment.true_syringe_concentration[ligand],
pymc.distributions.Lognormal):
mcmc.use_step_method(
RescalingStep, {
'Ls':
experiment.true_syringe_concentration[ligand],
'P0':
experiment.true_cell_concentration[receptor],
'DeltaH':
self.thermodynamic_parameters['DeltaH of %s * %s' %
(receptor, ligand)],
'DeltaG':
self.thermodynamic_parameters['DeltaG of %s * %s' %
(receptor, ligand)]
}, self.beta)
self.mcmc = mcmc
def __init__(self, experiment):
# Determine number of observations.
self.N = experiment.number_of_injections
self.DeltaVn = Quantity(numpy.zeros(self.N), ureg.microliter)
# Store injection volumes
for inj, injection in enumerate(experiment.injections):
self.DeltaVn[inj] = injection.volume
# Store calorimeter properties.
self.V0 = experiment.cell_volume
# Extract properties from experiment
self.experiment = experiment
if not len(experiment.syringe_concentration) == 1:
raise ValueError(
'TwoComponent model only supports one component in the syringe, found %d'
% len(experiment.syringe_concentration))
# python 2/3 compatibility
try:
Ls_stated = experiment.syringe_concentration.itervalues().next()
except AttributeError:
Ls_stated = next(iter(experiment.syringe_concentration.values()))
if not len(experiment.cell_concentration) == 1:
raise ValueError(
'TwoComponent model only supports one component in the cell, found %d'
% len(experiment.cell_concentration))
# python 2/3 compatibility
try:
P0_stated = experiment.cell_concentration.itervalues().next()
except AttributeError:
P0_stated = next(iter(experiment.cell_concentration.values()))
# Store temperature.
self.temperature = experiment.target_temperature # (kelvin)
self.beta = 1.0 / (ureg.molar_gas_constant * self.temperature
) # inverse temperature 1/(kcal/mol)
# Compute uncertainties in stated concentrations.
dP0 = 0.10 * P0_stated # uncertainty in protein stated concentration (M) - 10% error
dLs = 0.10 * Ls_stated # uncertainty in ligand stated concentration (M) - 10% error
# Determine guesses for initial values
q_n = Quantity(numpy.zeros(len(experiment.injections)),
'microcalorie / mole')
for inj, injection in enumerate(experiment.injections):
q_n[inj] = injection.evolved_heat / (
numpy.sum(injection.titrant)
) # TODO reduce to one titrant (from .itc file)
# TODO better initial guesses for everything
log_sigma_guess = log(
q_n[-4:].std() / (ureg.microcalorie /
ureg.mole)) # review: how can we do this better?
DeltaG_guess = -8.3 * ureg.kilocalorie / ureg.mol # todo add option to supply literature values
DeltaH_guess = -12.0 * ureg.kilocalorie / ureg.mol
#Assume the last injection has the best guess for H0
DeltaH_0_guess = q_n[-1] # ucal/injection
# Determine min and max range for log_sigma
log_sigma_min = log_sigma_guess - 10
log_sigma_max = log_sigma_guess + 5
# Determine range for priors for thermodynamic parameters.
DeltaG_min = -40. * ureg.kilocalorie / ureg.mol # (kcal/mol)
DeltaG_max = +40. * ureg.kilocalorie / ureg.mol # (kcal/mol)
DeltaH_min = -100. * ureg.kilocalorie / ureg.mol # (kcal/mol)
DeltaH_max = +100. * ureg.kilocalorie / ureg.mol # (kcal/mol)
# review dH = dQ, so is the unit of H0 cal, or cal/mol? Where does the mol come into the equation.
heat_interval = (q_n.max() - q_n.min())
DeltaH_0_min = q_n.min() - heat_interval # (cal/mol)
DeltaH_0_max = q_n.max() + heat_interval # (cal/mol)
# Define priors for concentrations.
# TODO convert everything to a consistent unit system
# review check out all the units to make sure that they're appropriate
self.P0 = pymc.Lognormal('P0',
mu=log(P0_stated / ureg.micromolar),
tau=1.0 / log(1.0 + (dP0 / P0_stated)**2),
value=P0_stated / ureg.micromolar)
self.Ls = pymc.Lognormal('Ls',
mu=log(Ls_stated / ureg.micromolar),
tau=1.0 / log(1.0 + (dLs / Ls_stated)**2),
value=Ls_stated / ureg.micromolar)
# Define priors for thermodynamic quantities.
self.log_sigma = pymc.Uniform('log_sigma',
lower=log_sigma_min,
upper=log_sigma_max,
value=log_sigma_guess)
self.DeltaG = pymc.Uniform(
'DeltaG',
lower=DeltaG_min / (ureg.kilocalorie / ureg.mol),
upper=DeltaG_max / (ureg.kilocalorie / ureg.mol),
value=DeltaG_guess / (ureg.kilocalorie / ureg.mol))
self.DeltaH = pymc.Uniform(
'DeltaH',
lower=DeltaH_min / (ureg.kilocalorie / ureg.mol),
upper=DeltaH_max / (ureg.kilocalorie / ureg.mol),
value=DeltaH_guess / (ureg.kilocalorie / ureg.mol))
# review make sure we get the units right on this.
self.DeltaH_0 = pymc.Uniform('DeltaH_0',
lower=DeltaH_0_min / ureg.microcalorie,
upper=DeltaH_0_max / ureg.microcalorie,
value=DeltaH_0_guess / ureg.microcalorie)
q_n_model = pymc.Lambda(
'q_n_model',
lambda P0=self.P0, Ls=self.Ls, DeltaG=self.DeltaG, DeltaH=self.
DeltaH, DeltaH_0=self.DeltaH_0: self.expected_injection_heats(
self.V0, self.DeltaVn, P0, Ls, DeltaG, DeltaH, DeltaH_0, self.
beta, self.N))
tau = pymc.Lambda('tau',
lambda log_sigma=self.log_sigma: self.tau(log_sigma))
# Review doublecheck equation
q_ns = Quantity(numpy.zeros(experiment.number_of_injections),
'microcalorie / mole')
for inj, injection in enumerate(experiment.injections):
q_ns[inj] = injection.evolved_heat / injection.titrant
# Define observed data.
self.q_n_obs = pymc.Normal('q_n',
mu=q_n_model,
tau=tau,
observed=True,
value=q_ns /
Quantity('microcalorie / mole'))
# Create sampler.
mcmc = pymc.MCMC(self, db='ram')
mcmc.use_step_method(pymc.Metropolis, self.DeltaG)
mcmc.use_step_method(pymc.Metropolis, self.DeltaH)
mcmc.use_step_method(pymc.Metropolis, self.DeltaH_0)
if P0_stated > Quantity('0.0 molar') and Ls_stated > Quantity(
'0.0 molar'):
mcmc.use_step_method(
RescalingStep, {
'Ls': self.Ls,
'P0': self.P0,
'DeltaH': self.DeltaH,
'DeltaG': self.DeltaG
}, self.beta)
elif experiment.cell_concentration > Quantity('0.0 molar'):
mcmc.use_step_method(pymc.Metropolis, self.P0)
elif experiment.syringe_concentration > Quantity('0.0 molar'):
mcmc.use_step_method(pymc.Metropolis, self.Ls)
self.mcmc = mcmc
return
import pymc as pm
import pymc.gp as gp
from pymc.gp.cov_funs import matern
import numpy as np
import matplotlib.pyplot as pl
from numpy.random import normal
x = np.arange(-1., 1., .1)
# Prior parameters of C
diff_degree = pm.Uniform('diff_degree', 1., 3)
amp = pm.Lognormal('amp', mu=.4, tau=1.)
scale = pm.Lognormal('scale', mu=.5, tau=1.)
# The covariance dtrm C is valued as a Covariance object.
@pm.deterministic
def C(eval_fun=gp.matern.euclidean,
diff_degree=diff_degree,
amp=amp,
scale=scale):
return gp.NearlyFullRankCovariance(eval_fun,
diff_degree=diff_degree,
amp=amp,
scale=scale)
# Prior parameters of M
a = pm.Normal('a', mu=1., tau=1.)
b = pm.Normal('b', mu=.5, tau=1.)
return -np.inf
return (-0.5 - num_partition) * np.log(np.array(value).sum())
@pm.stochastic
def prior_for_dirichlet_distribution_partition5(num_partition = 5, value = [1.] * 5):
if np.any(value <= 0):
return -np.inf
return (-0.5 - num_partition) * np.log(np.array(value).sum())
@pm.stochastic
def prior_for_dirichlet_distribution_partition6(num_partition = 6, value = [1.] * 6):
if np.any(value <= 0):
return -np.inf
return (-0.5 - num_partition) * np.log(np.array(value).sum())
dirichlet_process_prior = pm.Lognormal('dirichlet_process_prior', mu = 0, tau = 4)
@pm.stochastic(dtype = int)
def cut_1(value = np.array([[1, 5, 0, 0, 0, 0, 0, 2, 1]] * DATA_SIZE):
p_all = 0
for i in range(DATA_SIZE):
parent_node_index = value[i][7]
cut_partition_num = value[i][8]
rest_partion_num = 6 - parent_node_index - cut_partition_num
rest_index_start = parent_node_inde + cut_partition_num
next_parent_node_index = range(parent_node_index, rest_index_start)[value[i][9]]
if (value[i][7] == np.min(np.where(ORIGIN > 1))) \
and (value[i][next_parent_node_index] == np.min(np.where(value[i] > 1))) \
and (list(value[i][next_parent_node_index + 1 : next_parent_node_index + 1 + rest_partion_num]) == list(ORIGIN[parent_node_index + 1:])
Created on Mon Sep 04 18:17:59 2017
@author: Edward Coen
"""
import pymc as pm
import numpy as np
import scipy.special as ss
PRIOR_STD = 1
PRIOR_CORRELATION = 0.5
MAX_DIMENSION = 6
dirichilet_process_prior = pm.Lognormal('dirichilet_process_prior_mean',
mu=0,
tau=1)
dirichilet_distribution_prior_mean = pm.Lognormal(
'dirichilet_distribution_prior_mean', mu=3, tau=1.0 / 4)
a = pm.Beta('aa',
alpha=dirichilet_process_prior,
beta=dirichilet_distribution_prior_mean)
mcmc2 = pm.MCMC(
[dirichilet_process_prior, dirichilet_distribution_prior_mean, a])
mcmc2.sample(1000, 0, 1)
pm.Matplot.plot(mcmc2)
dirichilet_distribution_prior_std = pm.Uniform(
'dirichilet_distribution_prior_std', lower=0.99, upper=1.001)
dirichilet_distribution_prior_correlation = pm.Uniform(
'dirichilet_distribution_prior_correlation', lower=0.499, upper=0.501)
def __init__(self, Ls_stated, P0_stated, q_n_observed, DeltaVn,
temperature, V0):
# Determine number of observations.
self.N = q_n_observed.size
# Store injection volumes
if not numpy.iterable(DeltaVn):
self.DeltaVn = numpy.ones([self.N], numpy.float64) * DeltaVn
else:
self.DeltaVn = numpy.array(DeltaVn)
# Store calorimeter properties.
self.V0 = V0
# Store temperature.
self.temperature = temperature # temperature (kelvin)
self.beta = 1.0 / (kB * temperature
) # inverse temperature 1/(kcal/mol)
# Compute uncertainties in stated concentrations.
dP0 = 0.10 * P0_stated # uncertainty in protein stated concentration (M) - 10% error
dLs = 0.10 * Ls_stated # uncertainty in ligand stated concentration (M) - 10% error
# Determine guesses for initial values
log_sigma_guess = log(q_n_observed[-4:].std()) # cal/injection
DeltaG_guess = -8.3 # kcal/mol
DeltaH_guess = -12.0 # kcal/mol
DeltaH_0_guess = q_n_observed[-1] # cal/injection
# Determine min and max range for log_sigma
log_sigma_min = log_sigma_guess - 10
log_sigma_max = log_sigma_guess + 5
# Determine range for priors for thermodynamic parameters.
DeltaG_min = -40. # (kcal/mol)
DeltaG_max = +40. # (kcal/mol)
DeltaH_min = -100. # (kcal/mol)
DeltaH_max = +100. # (kcal/mol)
heat_interval = q_n_observed.max() - q_n_observed.min()
DeltaH_0_min = q_n_observed.min() - heat_interval # (cal/mol)
DeltaH_0_max = q_n_observed.max() + heat_interval # (cal/mol)
# Define priors for concentrations.
#self.P0 = pymc.Normal('P0', mu=P0_stated, tau=1.0/dP0**2, value=P0_stated)
#self.Ls = pymc.Normal('Ls', mu=Ls_stated, tau=1.0/dLs**2, value=Ls_stated)
self.P0 = pymc.Lognormal('P0',
mu=log(P0_stated),
tau=1.0 / log(1.0 + (dP0 / P0_stated)**2),
value=P0_stated)
self.Ls = pymc.Lognormal('Ls',
mu=log(Ls_stated),
tau=1.0 / log(1.0 + (dLs / Ls_stated)**2),
value=Ls_stated)
# Define priors for thermodynamic quantities.
self.log_sigma = pymc.Uniform('log_sigma',
lower=log_sigma_min,
upper=log_sigma_max,
value=log_sigma_guess)
self.DeltaG = pymc.Uniform('DeltaG',
lower=DeltaG_min,
upper=DeltaG_max,
value=DeltaG_guess)
self.DeltaH = pymc.Uniform('DeltaH',
lower=DeltaH_min,
upper=DeltaH_max,
value=DeltaH_guess)
self.DeltaH_0 = pymc.Uniform('DeltaH_0',
lower=DeltaH_0_min,
upper=DeltaH_0_max,
value=DeltaH_0_guess)
# Deterministic functions.
q_n_model = pymc.Lambda(
'q_n_model',
lambda P0=self.P0, Ls=self.Ls, DeltaG=self.DeltaG, DeltaH=self.
DeltaH, DeltaH_0=self.DeltaH_0, q_n_obs=
self.DeltaH_0: self.expected_injection_heats(
P0, Ls, DeltaG, DeltaH, DeltaH_0, q_n_obs))
tau = pymc.Lambda('tau',
lambda log_sigma=self.log_sigma: self.tau(log_sigma))
# Define observed data.
self.q_n_obs = pymc.Normal('q_n',
mu=q_n_model,
tau=tau,
observed=True,
value=q_n_observed)
# Create sampler.
mcmc = pymc.MCMC(self, db='ram')
mcmc.use_step_method(pymc.Metropolis, self.DeltaG)
mcmc.use_step_method(pymc.Metropolis, self.DeltaH)
mcmc.use_step_method(pymc.Metropolis, self.DeltaH_0)
mcmc.use_step_method(pymc.Metropolis, self.P0)
mcmc.use_step_method(pymc.Metropolis, self.Ls)
mcmc.use_step_method(
RescalingStep, {
'Ls': self.Ls,
'P0': self.P0,
'DeltaH': self.DeltaH,
'DeltaG': self.DeltaG
}, self.beta)
self.mcmc = mcmc
return
fermiindex = np.argmax(ergy >= 0)
# load in data
dos_d = np.loadtxt('dos_d.txt')
y1_data = np.loadtxt('dos_ads.txt')
y2_data = np.load('E.npy')
# priors
Initeffadse = -5.0 #-5.0
Initbeta = 2.1 #2.0
Initdelta = 1.0 #1.0
InitAlpha = 0.036 #.5
InitEsp = -3.25 #-2.0
effadse = pm.Normal('effadse', -5.0, 1, value=Initeffadse)
beta = pm.Lognormal('beta', 2, 1, value=Initbeta)
delta = pm.Lognormal('delta', 1, 0.25, value=Initdelta)
alpha = pm.Uniform('alpha', 0, 1.0, value=InitAlpha)
Esp = pm.Normal('Esp', -3.25, 1, value=InitEsp)
var_1 = pm.InverseGamma('var_1', 2.0, 0.05, value=0.05)
var_2 = pm.InverseGamma('var_2', 2.0, 0.1, value=0.1)
a = len(ergy)
@pm.stochastic(observed=True)
def custom_stochastic(effadse=effadse,
beta=beta,
delta=delta,
alpha=alpha,
