def astep(self, q0, logp):
self.w = np.resize(self.w, len(q0)) # this is a repmat
q = np.copy(q0) # TODO: find out if we need this
ql = np.copy(q0) # l for left boundary
qr = np.copy(q0) # r for right boudary
for i in range(len(q0)):
# uniformly sample from 0 to p(q), but in log space
y = logp(q) - nr.standard_exponential()
ql[i] = q[i] - nr.uniform(0, self.w[i])
qr[i] = q[i] + self.w[i]
# Stepping out procedure
while(y <= logp(ql)): # changed lt to leq for locally uniform posteriors
ql[i] -= self.w[i]
while(y <= logp(qr)):
qr[i] += self.w[i]
q[i] = nr.uniform(ql[i], qr[i])
while logp(q) < y: # Changed leq to lt, to accomodate for locally flat posteriors
# Sample uniformly from slice
if q[i] > q0[i]:
qr[i] = q[i]
elif q[i] < q0[i]:
ql[i] = q[i]
q[i] = nr.uniform(ql[i], qr[i])
if self.tune: # I was under impression from MacKays lectures that slice width can be tuned without
# breaking markovianness. Can we do it regardless of self.tune?(@madanh)
self.w[i] = self.w[i] * (self.n_tunes / (self.n_tunes + 1)) +\
(qr[i] - ql[i]) / (self.n_tunes + 1) # same as before
# unobvious and important: return qr and ql to the same point
qr[i] = q[i]
ql[i] = q[i]
if self.tune:
self.n_tunes += 1
return q
def astep(self, q0, logp):
"""q0 : current state
logp : log probability function
"""
# Draw from the normal prior by multiplying the Cholesky decomposition
# of the covariance with draws from a standard normal
chol = draw_values([self.prior_chol])
nu = np.dot(chol, nr.randn(chol.shape[0]))
y = logp(q0) - nr.standard_exponential()
# Draw initial proposal and propose a candidate point
theta = nr.uniform(0, 2 * np.pi)
theta_max = theta
theta_min = theta - 2 * np.pi
q_new = q0 * np.cos(theta) + nu * np.sin(theta)
while logp(q_new) <= y:
# Shrink the bracket and propose a new point
if theta < 0:
theta_min = theta
else:
theta_max = theta
theta = nr.uniform(theta_min, theta_max)
q_new = q0 * np.cos(theta) + nu * np.sin(theta)
return q_new
def astep(self, q0, logp):
self.w = np.resize(self.w, len(q0))
y = logp(q0) - nr.standard_exponential()
# Stepping out procedure
q_left = q0 - nr.uniform(0, self.w)
q_right = q_left + self.w
while (y < logp(q_left)).all():
q_left -= self.w
while (y < logp(q_right)).all():
q_right += self.w
q = nr.uniform(q_left, q_right,
size=q_left.size) # new variable to avoid copies
while logp(q) <= y:
# Sample uniformly from slice
if (q > q0).all():
q_right = q
elif (q < q0).all():
q_left = q
q = nr.uniform(q_left, q_right, size=q_left.size)
if self.tune:
# Tune sampler parameters
self.w_sum += np.abs(q0 - q)
self.n_tunes += 1.
self.w = 2. * self.w_sum / self.n_tunes
return q
def astep(self, q0, logp):
self.w = np.resize(self.w, len(q0)) # this is a repmat
q = np.copy(q0) # TODO: find out if we need this
ql = np.copy(q0) # l for left boundary
qr = np.copy(q0) # r for right boudary
for i in range(len(q0)):
# uniformly sample from 0 to p(q), but in log space
y = logp(q) - nr.standard_exponential()
ql[i] = q[i] - nr.uniform(0, self.w[i])
qr[i] = q[i] + self.w[i]
# Stepping out procedure
while(y <= logp(ql)): # changed lt to leq for locally uniform posteriors
ql[i] -= self.w[i]
while(y <= logp(qr)):
qr[i] += self.w[i]
q[i] = nr.uniform(ql[i], qr[i])
while logp(q) < y: # Changed leq to lt, to accomodate for locally flat posteriors
# Sample uniformly from slice
if q[i] > q0[i]:
qr[i] = q[i]
elif q[i] < q0[i]:
ql[i] = q[i]
q[i] = nr.uniform(ql[i], qr[i])
if self.tune: # I was under impression from MacKays lectures that slice width can be tuned without
# breaking markovianness. Can we do it regardless of self.tune?(@madanh)
self.w[i] = self.w[i] * (self.n_tunes / (self.n_tunes + 1)) +\
(qr[i] - ql[i]) / (self.n_tunes + 1) # same as before
# unobvious and important: return qr and ql to the same point
qr[i] = q[i]
ql[i] = q[i]
if self.tune:
self.n_tunes += 1
return q
def astep(self, q0, logp):
self.w = np.resize(self.w, len(q0))
y = logp(q0) - nr.standard_exponential()
# Stepping out procedure
q_left = q0 - nr.uniform(0, self.w)
q_right = q_left + self.w
while (y < logp(q_left)).all():
q_left -= self.w
while (y < logp(q_right)).all():
q_right += self.w
q = nr.uniform(q_left, q_right, size=q_left.size) # new variable to avoid copies
while logp(q) <= y:
# Sample uniformly from slice
if (q > q0).all():
q_right = q
elif (q < q0).all():
q_left = q
q = nr.uniform(q_left, q_right, size=q_left.size)
if self.tune:
# Tune sampler parameters
self.w_sum += np.abs(q0 - q)
self.n_tunes += 1.
self.w = 2. * self.w_sum / self.n_tunes
return q
def poisson_2D_array(center, M, d):
'''
Create array of 2D positions drawn from Poisson process.
Parameters
----------
center: array_like
The center of the array
M: int
The number of points in the first dimension
M: int
The number of points in the second dimension
phi: float
The counterclockwise rotation of the array (from the x-axis)
d: float
The distance between neighboring points
Returns
-------
ndarray (2, M * N)
The array of points
'''
from numpy.random import standard_exponential, randint
R = d * standard_exponential((2, M)) * (2 * randint(0, 2, (2, M)) - 1)
R = R.cumsum(axis=1)
R -= R.mean(axis=1)[:, np.newaxis]
R += np.array([center]).T
return R
def a_step(self, **q0):
# set the slice
logL = self.logp(**q0)
ϑ = logL - nr.standard_exponential()
# draw from prior
nu = {}
for v in self.vars:
μ = self.mu[v.name]
Σ = self.sd[v.name]
nu[v.name] = randn(μ, Σ)
# set up a bracket around the current point
φ = nr.uniform(low=0.0, high=self.width)
φmin = φ - self.width
φmax = φ
while True:
c, s = np.cos(φ), np.sin(φ)
q1 = {}
for v in self.vars:
x, ν, μ = q0[v.name], nu[v.name], self.mu[v.name]
q1[v.name] = (x - μ) * c + (ν - μ) * s + μ
logL = self.logp(**q1)
if logL > ϑ:
return q1
if φ > 0:
φmax = φ
elif φ < 0:
φmin = φ
else:
raise RuntimeError()
φ = nr.uniform(low=φmin, high=φmax)
def astep(self, q0, logp):
"""q0: current state
logp: log probability function
"""
# Draw from the normal prior by multiplying the Cholesky decomposition
# of the covariance with draws from a standard normal
# XXX: This needs to be refactored
chol = None # draw_values([self.prior_chol])[0]
nu = np.dot(chol, nr.randn(chol.shape[0]))
y = logp(q0) - nr.standard_exponential()
# Draw initial proposal and propose a candidate point
theta = nr.uniform(0, 2 * np.pi)
theta_max = theta
theta_min = theta - 2 * np.pi
q_new = q0 * np.cos(theta) + nu * np.sin(theta)
while logp(q_new) <= y:
# Shrink the bracket and propose a new point
if theta < 0:
theta_min = theta
else:
theta_max = theta
theta = nr.uniform(theta_min, theta_max)
q_new = q0 * np.cos(theta) + nu * np.sin(theta)
return q_new
def astep(self, q0, logp):
q0_val = q0.data
self.w = np.resize(self.w, len(q0_val)) # this is a repmat
q = np.copy(q0_val) # TODO: find out if we need this
ql = np.copy(q0_val) # l for left boundary
qr = np.copy(q0_val) # r for right boudary
for i in range(len(q0_val)):
# uniformly sample from 0 to p(q), but in log space
q_ra = RaveledVars(q, q0.point_map_info)
y = logp(q_ra) - nr.standard_exponential()
ql[i] = q[i] - nr.uniform(0, self.w[i])
qr[i] = q[i] + self.w[i]
# Stepping out procedure
cnt = 0
while y <= logp(
RaveledVars(ql, q0.point_map_info)
): # changed lt to leq for locally uniform posteriors
ql[i] -= self.w[i]
cnt += 1
if cnt > self.iter_limit:
raise RuntimeError(LOOP_ERR_MSG % self.iter_limit)
cnt = 0
while y <= logp(RaveledVars(qr, q0.point_map_info)):
qr[i] += self.w[i]
cnt += 1
if cnt > self.iter_limit:
raise RuntimeError(LOOP_ERR_MSG % self.iter_limit)
cnt = 0
q[i] = nr.uniform(ql[i], qr[i])
while logp(
q_ra
) < y: # Changed leq to lt, to accomodate for locally flat posteriors
# Sample uniformly from slice
if q[i] > q0_val[i]:
qr[i] = q[i]
elif q[i] < q0_val[i]:
ql[i] = q[i]
q[i] = nr.uniform(ql[i], qr[i])
cnt += 1
if cnt > self.iter_limit:
raise RuntimeError(LOOP_ERR_MSG % self.iter_limit)
if (
self.tune
): # I was under impression from MacKays lectures that slice width can be tuned without
# breaking markovianness. Can we do it regardless of self.tune?(@madanh)
self.w[i] = self.w[i] * (self.n_tunes / (self.n_tunes + 1)) + (
qr[i] - ql[i]) / (self.n_tunes + 1) # same as before
# unobvious and important: return qr and ql to the same point
qr[i] = q[i]
ql[i] = q[i]
if self.tune:
self.n_tunes += 1
return q
def poisson(cls, Fs, center, M, d):
''' Create beamformer with microphone positions drawn from Poisson process '''
from numpy.random import standard_exponential, randint
R = d*standard_exponential((2, M))*(2*randint(0,2, (2,M)) - 1)
R = R.cumsum(axis=1)
R -= R.mean(axis=1)[:,np.newaxis]
R += np.array([center]).T
return Beamformer(R, Fs)
def poisson2DArray(center, M, d):
''' Create array of 2D positions drawn from Poisson process '''
from numpy.random import standard_exponential, randint
R = d*standard_exponential((2, M))*(2*randint(0,2, (2,M)) - 1)
R = R.cumsum(axis=1)
R -= R.mean(axis=1)[:,np.newaxis]
R += np.array([center]).T
return R
def poisson_2D_array(center, M, d):
''' Create array of 2D positions drawn from Poisson process. '''
from numpy.random import standard_exponential, randint
R = d * standard_exponential((2, M)) * (2 * randint(0, 2, (2, M)) - 1)
R = R.cumsum(axis=1)
R -= R.mean(axis=1)[:, np.newaxis]
R += np.array([center]).T
return R
def _sample(self, q0):
"""
Helper function which implements slice sampler.
"""
self.w = np.resize(self.w, len(q0)) # this is a repmat
q = np.copy(q0)
ql = np.copy(q0) # l for left boundary
qr = np.copy(q0) # r for right boudary
for i, _ in enumerate(q0):
# uniformly sample from 0 to p(q), but in log space
y = self.model.logp(q) - nr.standard_exponential()
ql[i] = q[i] - nr.uniform(0, self.w[i])
qr[i] = q[i] + self.w[i]
# Stepping out procedure
cnt = 0
while y < self.model.logp(ql):
ql[i] -= self.w[i]
cnt += 1
if cnt > self.iter_limit:
raise RuntimeError(LOOP_ERR_MSG % self.iter_limit)
cnt = 0
while y < self.model.logp(qr):
qr[i] += self.w[i]
cnt += 1
if cnt > self.iter_limit:
raise RuntimeError(LOOP_ERR_MSG % self.iter_limit)
cnt = 0
q[i] = (qr[i] - ql[i]) * nr.rand() + ql[i]
while self.model.logp(q) < y:
# Sample uniformly from slice
if q[i] > q0[i]:
qr[i] = q[i]
elif q[i] < q0[i]:
ql[i] = q[i]
q[i] = (qr[i] - ql[i]) * nr.rand() + ql[i]
cnt += 1
if cnt > self.iter_limit:
raise RuntimeError(LOOP_ERR_MSG % self.iter_limit)
if self.tune:
self.w[i] = self.w[i] * (self.n_tunes / (self.n_tunes + 1)) +\
(qr[i] - ql[i]) / (self.n_tunes + 1) # same as before
qr[i] = q[i]
ql[i] = q[i]
if self.tune:
self.n_tunes += 1
return q
def astep(self, q0, logp):
q = q0.copy()
self.w = resize(self.w, len(q))
y = logp(q0) - standard_exponential()
# Stepping out procedure
ql = q0.copy()
ql -= uniform(0, self.w)
qr = q0.copy()
qr = ql + self.w
yl = logp(ql)
yr = logp(qr)
while ((y < yl).all()):
ql -= self.w
yl = logp(ql)
while ((y < yr).all()):
qr += self.w
yr = logp(qr)
q_next = q0.copy()
while True:
# Sample uniformly from slice
qi = uniform(ql, qr, size=ql.size)
yi = logp(qi)
if yi > y:
q = qi
break
elif (qi > q).all():
qr = qi
elif (qi < q).all():
ql = qi
if self.tune:
# Tune sampler parameters
self.w_tune.append(abs(q0 - q))
self.w = 2 * sum(self.w_tune, 0) / len(self.w_tune)
return q
def astep(self, q0, logp):
q = q0.copy()
self.w = np.resize(self.w, len(q))
y = logp(q0) - standard_exponential()
# Stepping out procedure
ql = q0.copy()
ql -= uniform(0, self.w)
qr = q0.copy()
qr = ql + self.w
yl = logp(ql)
yr = logp(qr)
while((y < yl).all()):
ql -= self.w
yl = logp(ql)
while((y < yr).all()):
qr += self.w
yr = logp(qr)
q_next = q0.copy()
while True:
# Sample uniformly from slice
qi = uniform(ql, qr)
yi = logp(qi)
if yi > y:
q = qi
break
elif (qi > q).all():
qr = qi
elif (qi < q).all():
ql = qi
if self.tune:
# Tune sampler parameters
self.w_tune.append(abs(q0 - q))
self.w = 2 * sum(self.w_tune, 0) / len(self.w_tune)
return q
def astep(self, q0, logp):
"""q0 : current state
logp : log probability function
"""
mean, cov = draw_values([self.prior_mean, self.prior_cov])
nu = nr.multivariate_normal(mean=mean, cov=cov)
y = logp(q0) - nr.standard_exponential()
# Draw initial proposal and propose a candidate point
theta = nr.uniform(0, 2 * np.pi)
theta_max = theta
theta_min = theta - 2 * np.pi
q_new = q0 * np.cos(theta) + nu * np.sin(theta)
while logp(q_new) <= y:
# Shrink the bracket and propose a new point
if theta < 0:
theta_min = theta
else:
theta_max = theta
theta = nr.uniform(theta_min, theta_max)
q_new = q0 * np.cos(theta) + nu * np.sin(theta)
return q_new
rv = Discrete(Z[risk], w=efron_w[risk])
info += rv.cov()
elif ties == 'cox':
raise NotImplementedError('Cox tie breaking method not \
implemented')
else:
raise NotImplementedError('tie breaking method not recognized')
return score
if __name__ == '__main__':
import numpy.random as R
n = 100
X = np.array([0]*n + [1]*n)
b = 0.4
lin = 1 + b*X
Y = R.standard_exponential((2*n,)) / lin
delta = R.binomial(1, 0.9, size=(2*n,))
subjects = [Observation(Y[i], delta[i]) for i in range(2*n)]
for i in range(2*n):
subjects[i].X = X[i]
import statsmodels.sandbox.formula as F
x = F.Quantitative('X')
f = F.Formula(x)
c = CoxPH(subjects, f)
# c.cache()
# temp file cleanup doesn't work on windows
c = CoxPH(subjects, f, time_dependent=True)
def __call__(self):
size = size(self.s)
return (standard_exponential(size=size) -
standard_exponential(size=size)) * self.s
def __call__(self, num_draws=None):
size = (self.s.shape)
if num_draws:
size += (num_draws, )
return (standard_exponential(size=size) -
standard_exponential(size=size)).T * self.s
def __call__(self):
size = np.size(self.s)
return (standard_exponential(size=size) - standard_exponential(size=size)) * self.s
def astep(self, q0, logp):
q0_val = q0.data
self.w = np.resize(self.w, len(q0_val)) # this is a repmat
q = np.copy(q0_val)
ql = np.copy(q0_val) # l for left boundary
qr = np.copy(q0_val) # r for right boudary
# The points are not copied, so it's fine to update them inplace in the
# loop below
q_ra = RaveledVars(q, q0.point_map_info)
ql_ra = RaveledVars(ql, q0.point_map_info)
qr_ra = RaveledVars(qr, q0.point_map_info)
for i, wi in enumerate(self.w):
# uniformly sample from 0 to p(q), but in log space
y = logp(q_ra) - nr.standard_exponential()
# Create initial interval
ql[i] = q[i] - nr.uniform() * wi # q[i] + r * w
qr[i] = ql[i] + wi # Equivalent to q[i] + (1-r) * w
# Stepping out procedure
cnt = 0
while y <= logp(
ql_ra
): # changed lt to leq for locally uniform posteriors
ql[i] -= wi
cnt += 1
if cnt > self.iter_limit:
raise RuntimeError(LOOP_ERR_MSG % self.iter_limit)
cnt = 0
while y <= logp(qr_ra):
qr[i] += wi
cnt += 1
if cnt > self.iter_limit:
raise RuntimeError(LOOP_ERR_MSG % self.iter_limit)
cnt = 0
q[i] = nr.uniform(ql[i], qr[i])
while y > logp(
q_ra
): # Changed leq to lt, to accomodate for locally flat posteriors
# Sample uniformly from slice
if q[i] > q0_val[i]:
qr[i] = q[i]
elif q[i] < q0_val[i]:
ql[i] = q[i]
q[i] = nr.uniform(ql[i], qr[i])
cnt += 1
if cnt > self.iter_limit:
raise RuntimeError(LOOP_ERR_MSG % self.iter_limit)
if self.tune:
# I was under impression from MacKays lectures that slice width can be tuned without
# breaking markovianness. Can we do it regardless of self.tune?(@madanh)
self.w[i] = wi * (self.n_tunes / (self.n_tunes + 1)) + (
qr[i] - ql[i]) / (self.n_tunes + 1)
# Set qr and ql to the accepted points (they matter for subsequent iterations)
qr[i] = ql[i] = q[i]
if self.tune:
self.n_tunes += 1
return q
def __call__(self):
size = np.size(self.s)
return (nr.standard_exponential(size=size) -
nr.standard_exponential(size=size)) * self.s
def standard_exponential(size, params):
try:
return random.standard_exponential(size, params['dtype'],
params['method'], params['out'])
except ValueError as e:
exit(e)
