def test_heritability_estimate_poisson():
random = RandomState(0)
G = random.randn(50, 100)
K = dot(G, G.T)
z = dot(G, random.randn(100)) / sqrt(100)
y = random.poisson(exp(z))
assert_allclose(estimate(y, "poisson", K, verbose=False),
0.991766763337491,
rtol=1e-3)
def test_heritability_estimate_poisson():
random = RandomState(0)
nsamples = 50
G = random.randn(50, 100)
K = dot(G, G.T)
z = dot(G, random.randn(100)) / sqrt(100)
y = random.poisson(exp(z))
assert_allclose(estimate(y, 'poisson', K, verbose=False),
0.6998737749318877)
def do(self, input_obj: ImageEntity, random_state_obj: RandomState) -> ImageEntity:
"""
Perform the actual noise insertion
:param input_obj: the input Entity to which noise is to be added
:param random_state_obj: a RandomState object used to sample the noise
:return: the transformed (noise added) Entity
"""
img = input_obj.get_data()
vals = len(np.unique(img))
vals = self.exponent_base ** np.ceil(np.log2(vals))
noisy = random_state_obj.poisson(img * vals) / float(vals)
logger.debug("Added Poisson Noise to Image")
return GenericImageEntity(noisy, input_obj.get_mask())
def test_glmmexpfam_poisson():
from numpy import ones, stack, exp, zeros
from numpy.random import RandomState
from numpy_sugar.linalg import economic_qs
from pandas import DataFrame
random = RandomState(1)
# sample size
n = 30
# covariates
offset = ones(n) * random.randn()
age = random.randint(16, 75, n)
M = stack((offset, age), axis=1)
M = DataFrame(stack([offset, age], axis=1), columns=["offset", "age"])
M["sample"] = [f"sample{i}" for i in range(n)]
M = M.set_index("sample")
# genetic variants
G = random.randn(n, 4)
# sampling the phenotype
alpha = random.randn(2)
beta = random.randn(4)
eps = random.randn(n)
y = M @ alpha + G @ beta + eps
# Whole genotype of each sample.
X = random.randn(n, 50)
# Estimate a kinship relationship between samples.
X_ = (X - X.mean(0)) / X.std(0) / sqrt(X.shape[1])
K = X_ @ X_.T + eye(n) * 0.1
# Update the phenotype
y += random.multivariate_normal(zeros(n), K)
y = (y - y.mean()) / y.std()
z = y.copy()
y = random.poisson(exp(z))
M = M - M.mean(0)
QS = economic_qs(K)
glmm = GLMMExpFam(y, "poisson", M, QS)
assert_allclose(glmm.lml(), -52.479557279193585)
glmm.fit(verbose=False)
assert_allclose(glmm.lml(), -34.09720756737648)
def _test_qtl_scan_st(lik):
random = RandomState(0)
n = 30
ncovariates = 3
M = random.randn(n, ncovariates)
v0 = random.rand()
v1 = random.rand()
G = random.randn(n, 4)
K = random.randn(n, n + 1)
K = normalise_covariance(K @ K.T)
beta = random.randn(ncovariates)
alpha = random.randn(G.shape[1])
m = M @ beta + G @ alpha
y = mvn(random, m, v0 * K + v1 * eye(n))
idx = [[0, 1], 2, [3]]
if lik == "poisson":
y = random.poisson(exp(y))
elif lik == "bernoulli":
y = random.binomial(1, 1 / (1 + exp(-y)))
elif lik == "probit":
y = random.binomial(1, st.norm.cdf(y))
elif lik == "binomial":
ntrials = random.randint(0, 30, len(y))
y = random.binomial(ntrials, 1 / (1 + exp(-y)))
lik = (lik, ntrials)
r = scan(G, y, lik=lik, idx=idx, K=K, M=M, verbose=False)
str(r)
str(r.stats.head())
str(r.effsizes["h2"].head())
str(r.h0.trait)
str(r.h0.likelihood)
str(r.h0.lml)
str(r.h0.effsizes)
str(r.h0.variances)
class PoissonArrivalDistribution(ValueEqual):
def __init__(self, minimal, lambdaFactor, seed=None):
super().__init__()
self._minimal = minimal
self._lambda = lambdaFactor
if seed is None:
seed = 0
self._seed = seed
self._random = RandomState(seed)
self._arrivalMap = {}
def _nonValueFields(self):
return '_random', '_arrivalMap'
@property
def minimal(self):
return self._minimal
@property
def lambdaFactor(self):
return self._lambda
def arrivalTime(self, releaseIndex):
if releaseIndex == 0:
return 0
if releaseIndex not in self._arrivalMap:
previous = self.arrivalTime(releaseIndex - 1)
sample = self._random.poisson(self._lambda) + self._minimal
arrival = sample + previous
self._arrivalMap[releaseIndex] = arrival
else:
arrival = self._arrivalMap[releaseIndex]
return arrival
def __repr__(self):
return "PoissonAD({}, {}, {})".format(self._minimal, self._lambda,
self._seed)
def test_glmmexpfam_poisson():
random = RandomState(1)
# sample size
n = 30
# covariates
offset = ones(n) * random.randn()
age = random.randint(16, 75, n)
M = stack((offset, age), axis=1)
# genetic variants
G = random.randn(n, 4)
# sampling the phenotype
alpha = random.randn(2)
beta = random.randn(4)
eps = random.randn(n)
y = M @ alpha + G @ beta + eps
# Whole genotype of each sample.
X = random.randn(n, 50)
# Estimate a kinship relationship between samples.
X_ = (X - X.mean(0)) / X.std(0) / sqrt(X.shape[1])
K = X_ @ X_.T + eye(n) * 0.1
# Update the phenotype
y += random.multivariate_normal(zeros(n), K)
y = (y - y.mean()) / y.std()
z = y.copy()
y = random.poisson(exp(z))
M = M - M.mean(0)
QS = economic_qs(K)
glmm = GLMMExpFam(y, "poisson", M, QS)
assert_allclose(glmm.lml(), -52.479557279193585)
glmm.fit(verbose=False)
assert_allclose(glmm.lml(), -34.09720756737648)
def test_poisson_optimize():
random = RandomState(139)
nsamples = 30
nfeatures = 31
G = random.randn(nsamples, nfeatures) / sqrt(nfeatures)
u = random.randn(nfeatures)
z = 0.1 + 2 * dot(G, u) + random.randn(nsamples)
y = zeros(nsamples)
for i in range(nsamples):
y[i] = random.poisson(lam=exp(z[i]))
(Q0, Q1), S0 = economic_qs_linear(G)
M = ones((nsamples, 1))
lik = PoissonProdLik(LogLink())
lik.noccurrences = y
ep = ExpFamEP(lik, M, Q0, Q1, S0)
ep.learn()
assert_almost_equal(ep.lml(), -77.90919831238075, decimal=2)
assert_almost_equal(ep.beta[0], 0.314709077094, decimal=1)
assert_almost_equal(ep.heritability, 0.797775054939, decimal=1)
for interval_count in range(4):
for do_while in range(100):
start_time = time.time()
stop_details = []
rand_generator = RandomState()
def gen_time(multiplicator, num):
return ((multiplicator - 1) * 10) + num
for stop in range(1, 6):
total_arrival_time = []
for time_idx in range(len(poisson_arrival)):
lam = poisson_arrival[time_idx]
num_passenger = int(
rand_generator.poisson(lam * SIMULATION_TIME) / 5)
passenger_arrival_time = numpy.sort(
rand(num_passenger) * SIMULATION_TIME)
for i in range(len(passenger_arrival_time)):
passenger_arrival_time[i] += (time_idx * 60)
total_arrival_time.extend(passenger_arrival_time)
stop_details.append(total_arrival_time)
# at this point, we have list of all queues across all stop
# now start bus journey
START_TIME = 5
LAST_BUS_TIME = 715
CURR_BUS_INTERVAL = 20 - (interval_count * 5)
INTERVAL_BETWEEN_STOPS = 10
BUS_CAPACITY = 50
class CaoMethod(DirectMethod):
n_crit = 10
tauleap_threshold = 10
micro_steps = 100
def __init__(self,
process,
state,
epsilon=0.03,
t=0.,
tmax=float('inf'),
steps=None,
seed=None):
super(CaoMethod, self).__init__(process,
state,
t=t,
tmax=tmax,
steps=steps,
seed=seed)
self.num_reactions = 0
self.epsilon = epsilon
self.rng2 = RandomState(seed)
self.abandon_tauleap = -1
def __iter__(self):
while not self.has_reached_end():
# step 1: partition reactions -- Eq. (10)
Jcrit, Jncr = self.identify_critical_reactions()
Irs = set(s for trans in self.transitions for s in trans.reactants)
Incr = set(s for trans in Jncr for s in trans.reactants)
if Incr:
# step 2: determine noncritical tau -- Eqs. (32) and (33)
mu = {
s: sum(
trans.stoichiometry.get(s, 0) * a
for trans, a in Jncr.items())
for s in Incr
}
var = {
s: sum(
trans.stoichiometry.get(s, 0)**2 * a
for trans, a in Jncr.items())
for s in Incr
}
eps = {
s: max(self.epsilon * self.state[s] * self.gi(s), 1.)
for s in Incr
}
tau_ncr1 = min((eps[s] / abs(mu[s])) if mu[s] else float('inf')
for s in Incr)
tau_ncr2 = min(
(eps[s]**2 / abs(var[s])) if var[s] else float('inf')
for s in Incr)
tau_ncr = min((tau_ncr1, tau_ncr2, self.tmax - self.time))
else:
tau_ncr = float('inf')
a0 = sum(mult * prop
for _, prop, mult in self.propensities.items())
if not a0:
break
while True:
# step 3: abandon tau leaping if not enough expected gain
if tau_ncr <= self.tauleap_threshold / a0:
if self.abandon_tauleap == -1:
self.abandon_tauleap = self.step
it = DirectMethod.__iter__(self)
for _ in range(self.micro_steps):
trans = next(it)
self.num_reactions += 1
yield self.time, self.state, {trans: 1}
break
elif self.abandon_tauleap != -1:
logging.debug("Abandoned tau-leaping for %d steps" %
(self.step - self.abandon_tauleap))
self.abandon_tauleap = -1
# step 4: determine critical tau
ac = sum(propensity for trans, propensity in Jcrit.items())
tau_crit = -log(self.rng.random()) / ac if ac else float('inf')
# step 5: determine actual tau
tau = min((tau_ncr, tau_crit, self.tmax - self.time))
# step 5a
firings = {
trans: self.rng2.poisson(propensity * tau)
for trans, propensity in Jncr.items()
}
firings = {trans: n for trans, n in firings.items() if n}
# step 5b
if tau == tau_crit:
# fire exactly one ciritical reaction
transition = None
pick = self.rng.random() * ac
for transition, propensity in Jcrit.items():
pick -= propensity
if pick < 0.:
break
firings[transition] = 1
new_reactions = sum(firings.values())
# avoid overshooting self.steps
if self.steps and self.step + new_reactions > self.steps:
tau_ncr /= 2
continue
all_reactants = sum(
(n * trans.true_reactants for trans, n in firings.items()),
multiset())
all_products = sum(
(n * trans.true_products for trans, n in firings.items()),
multiset())
net_reactants = all_reactants - all_products
net_products = all_products - all_reactants
# step 6a: avoid negative copy numbers
if any(self.state[s] < n for s, n in net_reactants.items()):
tau_ncr /= 2
continue
else:
# step 6b: perform transitions
self.time += tau
self.step += 1
self.num_reactions += new_reactions
self.state -= net_reactants
for rule in self.process.rules:
for trans in rule.infer_transitions(
net_products, self.state):
trans.rule = rule
self.add_transition(trans)
self.state += net_products
# update propensities
affected_species = set().union(*(trans.affected_species
for trans in firings))
affected = self.dependency_graph.affected_transitions(
affected_species)
self.update_propensities(affected)
self.prune_transitions()
yield self.time, self.state, firings
break
if self.step != self.steps and self.tmax < float('inf'):
self.time = self.tmax
def identify_critical_reactions(self):
def critical(trans, propensity):
if not propensity:
return False
elif not trans.true_reactants:
return False
elif L(trans) < self.n_crit:
return True
elif any(self.state[s] < rule.order for rule in self.process.rules
for s in trans.true_products):
return True
else:
return False
def L(trans):
return min(-float(self.state[s]) / trans.stoichiometry.get(s, 0)
for s in trans.true_reactants
if trans.stoichiometry.get(s, 0) < 0)
crit = {}
noncrit = {}
for trans, a, mult in self.propensities.items():
partition = crit if critical(trans, a) else noncrit
partition[trans] = mult * a
return crit, noncrit
def gi(self, species):
g = 0
for trans in self.transitions:
if species not in trans.reactants:
continue
order = sum(trans.reactants.values())
if order == 1:
g = max(g, 1)
elif order == 2 and trans.reactants[species] == 1:
g = max(g, 2)
elif order == 2 and trans.reactants[species] == 2:
g = max(g, 2 + (self.state[species] -
1)**-1) if self.state[species] >= 2 else 3
elif order == 3 and trans.reactants[species] == 1:
g = max(g, 3)
elif order == 3 and trans.reactants[species] == 2:
g = max(g, 1.5 * (2 + (self.state[species] - 1)**-1)
) if self.state[species] >= 2 else 4.5
elif order == 3 and trans.reactants[species] == 3:
g = max(
g, 3 + (self.state[species] - 1)**-1 +
(self.state[species] -
2)**-1) if self.state[species] >= 3 else 5.5
else:
raise RuntimeError(
"Tau-leaping not implemented for reactions of order %d" %
order)
return g
def randomu(seed, di=None, binomial=None, double=False, gamma=False,
normal=False, poisson=False):
"""
Replicates the randomu function avaiable within IDL
(Interactive Data Language, EXELISvis).
Returns an array of uniformly distributed random numbers of the
specified dimensions.
The randomu function returns one or more pseudo-random numbers
with one or more of the following distributions:
Uniform (default)
Gaussian
binomial
gamma
poisson
:param seed:
If seed is not of type mtrand.RandomState, then a new state is
initialised. Othersise seed will be used to generate the random
values.
:param di:
A list specifying the dimensions of the resulting array. If di
is a scalar then randomu returns a scalar.
Dimensions are D1, D2, D3...D8 (x,y,z,lambda...).
The list will be inverted to suit Python's inverted dimensions
i.e. (D3,D2,D1).
:param binomial:
Set this keyword to a list of length 2, [n,p], to generate
random deviates from a binomial distribution. If an event
occurs with probablility p, with n trials, then the number of
times it occurs has a binomial distribution.
:param double:
If set to True, then randomu will return a double precision
random numbers.
:param gamma:
Set this keyword to an integer order i > 0 to generate random
deviates from a gamm distribution.
:param Long:
If set to True, then randomu will return integer uniform
random deviates in the range [0...2^31-1], using the Mersenne
Twister algorithm. All other keywords will be ignored.
:param normal:
If set to True, then random deviates will be generated from a
normal distribution.
:param poisson:
Set this keyword to the mean number of events occurring during
a unit of time. The poisson keword returns a random deviate
drawn from a poisson distribution with that mean.
:param ULong:
If set to True, then randomu will return unsigned integer
uniform deviates in the range [0..2^32-1], using the Mersenne
Twister algorithm. All other keywords will be ignored.
:return:
A NumPy array of uniformly distributed random numbers of the
specified dimensions.
Example:
>>> seed = None
>>> x, sd = randomu(seed, [10,10])
>>> x, sd = randomu(seed, [100,100], binomial=[10,0.5])
>>> x, sd = randomu(seed, [100,100], gamma=2)
>>> # 200x by 100y array of normally distributed values
>>> x, sd = randomu(seed, [200,100], normal=True)
>>> # 1000 deviates from a poisson distribution with a mean of 1.5
>>> x, sd = randomu(seed, [1000], poisson=1.5)
>>> # Return a scalar from a uniform distribution
>>> x, sd = randomu(seed)
:author:
Josh Sixsmith, [email protected], [email protected]
:copyright:
Copyright (c) 2014, Josh Sixsmith
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project.
"""
# Initialise the data type
if double:
dtype = 'float64'
else:
dtype = 'float32'
# Check the seed
# http://stackoverflow.com/questions/5836335/consistenly-create-same-random-numpy-array
if type(seed) != mtrand.RandomState:
seed = RandomState()
if di is not None:
if type(di) is not list:
raise TypeError("Dimensions must be a list or None.")
if len(di) > 8:
raise ValueError("Error. More than 8 dimensions specified.")
# Invert the dimensions list
dims = di[::-1]
else:
dims = 1
# Python has issues with overflow:
# OverflowError: Python int too large to convert to C long
# Occurs with Long and ULong
#if Long:
# res = seed.random_integers(0, 2**31-1, dims)
# if di is None:
# res = res[0]
# return res, seed
#if ULong:
# res = seed.random_integers(0, 2**32-1, dims)
# if di is None:
# res = res[0]
# return res, seed
# Check for other keywords
distributions = 0
kwds = [binomial, gamma, normal, poisson]
for kwd in kwds:
if kwd:
distributions += 1
if distributions > 1:
print("Conflicting keywords.")
return
if binomial:
if len(binomial) != 2:
msg = "Error. binomial must contain [n,p] trials & probability."
raise ValueError(msg)
n = binomial[0]
p = binomial[1]
res = seed.binomial(n, p, dims)
elif gamma:
res = seed.gamma(gamma, size=dims)
elif normal:
res = seed.normal(0, 1, dims)
elif poisson:
res = seed.poisson(poisson, dims)
else:
res = seed.uniform(size=dims)
res = res.astype(dtype)
if di is None:
res = res[0]
return res, seed
