def module1(self,img):
'''
処理の概要
args : ->
dst : ->
param: ->
'''
# 図の準備
nrow = 2
ncol = 2
plt.subplots(nrow, ncol, figsize=(16,7))
gs = gridspec.GridSpec(nrow,ncol)
axs = [plt.subplot(gs[i]) for i in range(4) ]
# 一つ目の図の描画
rd.seed(0)
n = 141
x = np.linspace(0,140,n) # float64でつくる
y = rd.exponential(1.5, n) * 300 # 乱数じゃない
col = ["#2F79B0" for _ in range(n)] # colorの生成
for i in range(5):
y[60+i] = rd.exponential(1.5, 1) * 300 + 2000
col[60+i] = "r"
axs[0].scatter(x,y, c=col) #散布図の描画
axs[0].set_xlim(-5,145)
axs[0].set_xlabel('time',size=12)
plt.pause(3)
plt.show()
def homogeneous_process(t, rate):
r"""Generate a realisation of a Possion process.
Parameters
----------
t : scalar
The time length to realise. The events generated are between time 0 and `t`.
rate : scalar
The average rate of events.
Returns
-------
events : ndarry
An array containing the times of the events.
"""
# Generates the intervals between events from an exponential
# distribution (until total is time is greater than t) and then
# perform cumulative sum to find event times. Generates in blocks
# for efficiency.
n = int(1.2*rate*t + 1)
iv = rnd.exponential(1.0/rate, n)
n = int(0.4*rate*t + 1)
while (iv.sum() < t):
ivt = rnd.exponential(1.0/rate, n)
iv = np.concatenate((iv,ivt))
ts = np.cumsum(iv)
maxi = np.searchsorted(ts, [t])
return ts[:maxi]
def update():
global Occup
global t
t1=T
I,J=0,0
for i in range(0,2):
for j in range(0,2):
if Occup[i][j]!=0:
if i==j:
t2=rand.exponential(Lambda[i][j])
else:
t2=rand.exponential(Lambda[i][j]/Occup[i][j])
if t2<t1:
I,J=i,j
t1=t2
# print t1
if I==0 and J==0:
Occup[0][0]=Occup[0][0]-1
Occup[0][1]=Occup[0][1]+1
if I==1 and J==1:
Occup[1][1]=Occup[1][1]-1
Occup[1][0]=Occup[1][0]+1
if I==1 and J==0:
Occup[1][0]=Occup[1][0]-1
Occup[0][0]=Occup[0][0]+1
if I==0 and J==1:
Occup[0][1]=Occup[0][1]-1
Occup[1][1]=Occup[1][1]+1
t=t+t1
def __call__( self, w ) :
shuffle(self.values)
move= exponential(self.k) * self.values
neww = w + move
while not self.validrange( neww ) :
shuffle(self.values)
move= exponential(self.k) * self.values
neww = w + move
return neww
def rprior(size, hyperparameters):
""" returns untransformed parameters """
nu = random.exponential(scale = 1 / hyperparameters["nu_rate"], size = size)
xi = random.exponential(scale = 1 / hyperparameters["xi_rate"], size = size)
sigma = random.exponential(scale = 1 / hyperparameters["sigma_rate"], size = size)
parameters = zeros((3, size))
parameters[0, :] = nu
parameters[1, :] = xi
parameters[2, :] = sigma
return parameters
def rprior(size, hyperparameters):
""" returns untransformed parameters """
xi = random.exponential(scale = 1 / hyperparameters["xi_rate"], size = size)
omega2 = random.exponential(scale = 1 / hyperparameters["omega2_rate"], size = size)
lamb = random.exponential(scale = 1 / hyperparameters["lambda_rate"], size = size)
parameters = zeros((3, size))
parameters[0, :] = xi
parameters[1, :] = omega2
parameters[2, :] = lamb
return parameters
def rInitDistribution(size):
""" returns untransformed parameters """
xi = random.exponential(scale = 1, size = size)
omega2 = random.exponential(scale = 1, size = size)
lamb = random.exponential(scale = 1, size = size)
parameters = zeros((3, size))
parameters[0, :] = xi
parameters[1, :] = omega2
parameters[2, :] = lamb
return parameters
def rprior(size, hyperparameters):
""" returns untransformed parameters """
mu = norm.rvs(size = size, loc = hyperparameters["mu_mean"], scale = hyperparameters["mu_sd"])
beta = norm.rvs(size = size, loc = hyperparameters["beta_mean"], scale = hyperparameters["beta_sd"])
xi = random.exponential(scale = 1 / hyperparameters["xi_rate"], size = size)
omega2 = random.exponential(scale = 1 / hyperparameters["omega2_rate"], size = size)
lamb = random.exponential(scale = 1 / hyperparameters["lambda_rate"], size = size)
parameters = zeros((5, size))
parameters[0, :] = mu
parameters[1, :] = beta
parameters[2, :] = xi
parameters[3, :] = omega2
parameters[4, :] = lamb
return parameters
def sample(n):
T = DiGraph()
alive = dict()
heights = list()
total = 0.0
for i in range(n):
alive[i] = 0.0
k = n
while k > 1:
event = exponential(1.0/binom(k, 2))
total += event
heights.append(total)
for c in alive.keys():
alive[c] += event
[a, b] = subset(alive.keys(), 2)
c = new_node(k)
alive[a]
alive[b]
T.add_edge(a, c, length = alive[a])
T.add_edge(b, c, length = alive[b])
del alive[a]
del alive[b]
alive[c] = 0.0
k -= 1
T.below = collapse(T)
T.heights = heights
return T
def _sample_next_reaction(self):
"""
Use random sampling to select the next reaction and firing time.
Returns a tuple of (reaction, wait time). The wait time is the duration
from the current simulation time to the time the next reaction fires.
It is sampled from an exponential distribution.
Handles delayed reactions by looking back in the history and using the
state as it was (delay) time units ago.
"""
propensities = np.empty((len(self.reactions)))
for ridx, rxn in enumerate(self.reactions):
if rxn.delay == 0.0:
state = self.state
else:
state = self.sample_state(
self.time - rxn.delay, use_init_state=True)
propensities[ridx] = rxn.calc_propensity(state)
prop_csum = np.cumsum(propensities)
total_prop = prop_csum[-1]
wait_time = exponential(1.0 / total_prop)
rxn_selector = random() * total_prop
for ridx, rxn in enumerate(self.reactions):
if prop_csum[ridx] >= rxn_selector:
next_rxn = rxn
break
return (next_rxn, wait_time)
def MiExponential(rate):
"""Exponential Distribution Function
rate: Gamma of exp distribution"""
global manflag
if not manflag:
setManual()
return np.exponential(rate,1)
def simulator_alpha(theta, N=100):
"""
function that samples form the alpha stable distribution
theta is np.array([alpha, beta, gamma, delta])
"""
# unpack values
# theta = theta.astype(object)
alpha = theta[0,:]
beta = theta[1,:]
gamma = theta[2,:]
delta = theta[3,:]
# add random seed
random_seed = random.randrange(10**9)
np.random.seed(seed=random_seed)
# generate w and u for simulating
# pdb.set_trace()
w = nr.exponential(size=N)
u = nr.uniform(low=-np.pi/2., high=np.pi/2., size=N)
# w = w.astype(float)
# u = u.astype(float)
S_a_b = (1.+ beta**2. * np.tan(np.pi*alpha/2.)**2. )**(1/(2.*alpha))
B_a_b = 1./alpha * np.arctan(beta*np.tan(np.pi*alpha*0.5))
if alpha == 1.:
y_bar = 2./np.pi * ((np.pi/2. + beta*u)*np.tan(u)-beta*np.log(np.pi/2. * w *np.cos(u ) / (np.pi/2. + beta*u) ) )
else:
y_bar = S_a_b * ((np.sin(alpha)*(u + B_a_b ) ) / np.cos(u)**(1./alpha) ) * (np.cos(u-alpha*(u+ B_a_b ))/w) **((1-alpha)/alpha )
return S1_summary_statistic_alpha(y_bar*gamma+delta, theta)
def generate_newpath(self, known_first=False):
t_start = self.t_start
t_end = self.t_end
t = t_start
z = 0
rate_matrix = copy.deepcopy(self.rate_matrix)
if not known_first:
pi0 = self.initial_pi
s0 = sample_from_Multi(pi0)
self.s0 = s0
rate_list = abs(rate_matrix.diagonal())
S = []
T = []
temp_state = self.s0
while (t + z) < t_end:
t += z
current_state = temp_state
S.append(current_state)
if t > t_start:
T.append(t)
rate = rate_list[current_state]
z = random.exponential(1.0 / rate)
beta = rate_matrix[current_state]
beta[beta < 0] = 0
temp_state = sample_from_Multi(beta)
self.S = S
self.T = T
def sample(self, density, deviation, add_source_point=True, seed=None):
try: seed = int(seed)
except: seed = None
np_random.seed(seed)
self.sample_seed = seed
points = set()
for k, node in self.K.items():
if node.parent is None: continue
parent = self.K[node.parent]
avg_radius = (node.radius + parent.radius) / 2
axis = node.pos - parent.pos
surf = 2 * pi * avg_radius * linalg.norm(axis)
n = int(round(density * surf))
p1 = parent.pos
p2 = node.pos
p = np_random.randn(3)
r = cross(p-p1, p2-p1)
r /= linalg.norm(r)
s = cross(r, p2-p1)
s /= linalg.norm(s)
for i in range(n):
theta = np_random.uniform(0, radians(360))
d = np_random.uniform() # relative distance of the point, on line between p1 and p2
t = p1 + d * axis
interp_radius = (node.radius - parent.radius) * d + parent.radius
if deviation:
interp_radius += np_random.exponential(deviation)
q = harray([t[0] + interp_radius * cos(theta) * r[0] + interp_radius * sin(theta) * s[0],
t[1] + interp_radius * cos(theta) * r[1] + interp_radius * sin(theta) * s[1],
t[2] + interp_radius * cos(theta) * r[2] + interp_radius * sin(theta) * s[2]])
points.add(q)
if add_source_point:
points.add((0,-0.01,0))
self.P = vstack(points)
def mixture_process(nu, P, tauc, t):
'''
Generate correlated spike trains from a mixture process.
nu = rates of source spike trains
P = mixture matrix
tauc = correlation time constant
t = duration
Returns a list of (neuron_number,spike_time) to be passed to SpikeGeneratorGroup.
'''
n = array(poisson(nu * t)) # number of spikes for each source spike train
if n.ndim == 0:
n = array([n])
# Only non-zero entries:
nonzero = n.nonzero()[0]
n = n[nonzero]
P = array(P.take(nonzero, axis=1))
nik = binomial(n, P) # number of spikes from k in i
result = []
for k in xrange(P.shape[1]):
spikes = rand(n[k]) * t
for i in xrange(P.shape[0]):
m = nik[i, k]
if m > 0:
if tauc > 0:
selection = sample(spikes, m) + array(exponential(tauc, m))
else:
selection = sample(spikes, m)
result.extend(zip([i] * m, selection))
result = [(i,t*second) for i,t in result]
return result
def test_exp_1db(self):
"""
e^-x for x = 0..1 with g(x) = e^-x : alternate dist formulation
"""
npoints = 2000
self.run_all(lambda x:x<1.0,npoints,lambda size: exponential(size=(size,1)),
self.exp_integral(1),self.exp_variance(1))
def interarr(self,s,d,avgtraff,time):
if float(avgtraff) == 0:
return self.simdur + 1
rate = float(avgtraff)/self.flowsize
scale = 1.0/rate
nextarr = rv.exponential(scale,1)
return nextarr[0] + time
def testDrawVarying ():
#data = np.array ([8,5,4,2])
data0 = rnd.exponential (10, 30)
data1 = rnd.triangular (4, 5, 5, 20)
data2 = rnd.triangular (10,11,11, 10)
data3 = rnd.triangular (14,14,15, 5)
data4 = rnd.triangular (0,1,1, 10)
data = np.concatenate ((data0,data1,data2,data3,data4), axis=0)
#data = data0
data = rnd.beta (5,2,1000)
data = [10 * x for x in data]
#data0 = rnd.triangular (5, 5, 10, 100)
#data1 = rnd.triangular (10, 20, 20, 100)
#data2 = rnd.triangular (20, 21, 21, 0)
#data = np.concatenate ((data0, data1, data2), axis=0)
#data = rnd.triangular (0, 10, 15, 200)
data = np.sort (data)
#data = np.ceil (data, None)
blocks = bucket (data, limit=0.1, depth=3, individualSigma = 2.0, maxExtremas=0, minHeight=0.0)
draw (data, blocks=blocks)
def make_notes_and_sounds(model, T=SAMPLE_RATE * 1):
""" generate notes (t samples) from a generative music model
notes : T x N : |samples| x |notes|
default |samples| is 10sec
prototype models
which notes "n"
how loud "x"
what time "t"
doesn't need to sound like music
but should locally look like music
note
note := periodic modes + aperiodic attack
note : R | {0 1}
periodic note := sum-of-sines + phase|amplitude noise + decay
aperiodic note := correlated gaussian noise process
Genarative Model #1
each time, random chord
sample next time from gaussian
sample |notes| from exponential
TODO sample note duration
Genarative Model #2
noise
add gaussian noise = blur
swap samples
if hmm, then observation noise + transition noise variance
distort pitch
"""
print 'making notes and sounds...'
X = zeros(T)
Y = zeros((T, nNOTES))
T = X.size - AUDIO_SIZE - 1
over_notes = 0 if A.shape[0]==nNOTES else 1
t = max(0, int(sample.normal(1, 1)*SAMPLE_RATE))
while t<T:
Y[t,:] = sample.exponential(0.2, nNOTES)
Y[t,:][Y[t,:] < 0.5] = 0
# randomly zero or real
X[t:t+AUDIO_SIZE] = sum( Y[t,:] * A , axis=over_notes )
# Y weights A along Time
# broadcast (1,N) to (AUDIO_SIZE, N)
# sum over Notes
sigma = sample.randint(1,20)
# 1 sounds the same
# 100 sounds like nothing
X[t:t+AUDIO_SIZE] = gaussian_filter(X[t:t+AUDIO_SIZE], sigma)
t += max(1, int(sample.normal(1, 1)*SAMPLE_RATE))
return X,Y
def next(self):
p = None
if self.next_tick == self.cur_tick:
p = Packet(self.cur_tick)
num = ceil(random.exponential(1/self.lamb, None) * self.multiplier)
self.next_tick = self.cur_tick + num
self.cur_tick += 1
return p
def random(self, point=None, size=None, repeat=None):
mu, sigma, nu = draw_values([self.mu, self.sigma, self.nu],
point=point)
return generate_samples(lambda mu, sigma, nu, size=None: nr.normal(mu, sigma, size=size) +
nr.exponential(scale=nu, size=size),
mu, sigma, nu,
dist_shape=self.shape,
size=size)
def test_exp_6d(self):
"""
e^-(sum(x)) for x = 0..1 with g(x) = e^-(sum(x)) for d=6.
"""
npoints = 10000
self.run_all(lambda x:np.all(x<1.0),npoints,
lambda size:(exponential(size=(size,6))),
self.exp_integral(6),self.exp_variance(6))
def test_exp_2d(self):
"""
e^-(x+y) for x,y = 0..1 with g(x) = e^-(x+y)
"""
npoints = 2000
self.run_all(lambda xs:xs[0]<1.0 and xs[1]<1.0,npoints,
lambda size:(exponential(size=(size,2))),
self.exp_integral(2),self.exp_variance(2))
def next(self):
p = None
if self.nextPacket == self.curTime:
p = Packet(self.curTime)
num = ceil(random.exponential(1 / self.lamb, None) * self.multiplier)
self.nextPacket = self.curTime + num
self.curTime += 1
return p
def generate_poisson(self, tstart, tend, cadence):
n=int((tend-tstart)/cadence*2 + 20)
dts=cadence*nr.exponential(size=n)
ts=tstart + np.cumsum(dts)
return ts[ts<tend]
def execute(self, simulator):
"""Generates new customer at given time"""
print 'new customer at t= ' + str(self.time)
customer = Customer(simulator.time)
self.queue.insert(simulator, customer)
self.time += exponential(4)
if self.time < self.maxtime:
simulator.insert(self)
def generate_check_time(self,num_of_bags):
bag_time = 0
if num_of_bags == 0:
return 0
else:
for bag in xrange(1,num_of_bags):
bag_time += npr.exponential(scale=1,size=1)
return bag_time
def defineGroupSizes(n_groups, beta): sizes = [] #sample = pl.randht(n_groups,'cutoff',3,2,1.0/(beta)); sample = rd.exponential(beta,n_groups) for i in sample: sizes = sizes + [int(i)] print(sizes) return sizes
def Sample(self, count=1):
return self.DependentSample(count=count)
samples = random.exponential(np.exp(-self.LogLambda()), count * self.dimension)
samples = samples * np.sign(random.random(count * self.dimension) - 0.5)
samples = (samples.reshape(count, self.dimension)
+ self._state[0:self.dimension])
return samples
def main():
(options, args) = get_parser().parse_args()
assert int(options.dim) > 0
seed(int(options.seed) if options.seed else None)
for i in range(int(options.num)):
print (options.delim.join(["%s" % exponential(float(options.scale)) for x in range(int(options.dim))]))
def sample_hold_time(self, n=1):
"""
Samples the time to the n^th event
Homogenous Poisson Process
-> time to first event is exponential
-> time to kth event is Erlang (Gamma) distribution
-> sum of k exponentials
"""
if n > 1:
raise ValueError("I've not done this yet...")
if self.stationary:
scale = 1 / self.lambda0
return npr.exponential(scale=scale, size=1)
else:
return self.sample_hold_time_ns(n=1)
def person_generator(env, toilet, lam, mu, person_Num=None):
print('time: %6.2f, start' % env.now)
i = 0
if person_Num is None:
def flag(i):
return True # Noneのときは無限母集団として扱う。
else:
def flag(i):
return i < person_Num # 有限母集団。
while flag(i):
# 登場する時間間隔は指数分布
yield env.timeout(npr.exponential(1.0 / lam, size=1))
person = Person(env, 'person_%00d' % i, mu)
i += 1
env.process(person.behave(toilet)) # シミュレーション環境に実行するプロセスを追加
def _update_business_3__(self, pop, g_best):
pr = [i / self.pop_size for i in range(1, self.pop_size + 1)]
for i in range(self.pop_size):
X_new = deepcopy(pop[i][self.ID_POS])
for j in range(self.problem_size):
if random() > pr[i]:
i1, i2 = choice(self.pop_size, 2, replace=False)
e = exponential(0.5)
X1 = pop[i1][self.ID_POS]
X2 = pop[i2][self.ID_POS]
X_new[j] = X1[j] + e * (X2[j] - pop[i][self.ID_POS][j])
fit = self.get_fitness_position(position=X_new,
minmax=self.ID_MIN_PROB)
if fit < pop[i][self.ID_FIT]:
pop[i] = [X_new, fit]
return pop
def __init__(self, sourceId, targetId):
self.__type = 'Transaction'
self.id = uuid4()
self.source = sourceId
self.target = targetId
self.date = self._datetime.date(start=2015, end=2019)
self.time = self._datetime.time()
if random() < 0.05:
self.amount = self._numbers.between(100000, 1000000)
self.amount = npr.exponential(10)
if random() < 0.15:
self.currency = self._business.currency_iso_code()
else:
self.currency = None
def rndFindBlockTime(lamb):
global adjustCountUnder10
global adjustCountOver20
time = nprnd.exponential(1 / lamb)
mult = 1 + 1 / 2048 * max(1 - time // 10, -99) # difficult
if (np.absolute(1 / 2048 * max(1 - time // 10, -99)) > 0.01):
print(mult)
tm.sleep(0.1)
# mult = 1 + 1 / 2048 * max(2 - time // 9, -99) # difficulty
if (time < 10):
adjustCountUnder10 += 1
# print("up"
elif (time >= 20):
adjustCountOver20 += 1
# mult > 1: consensus時間を長くする, mult < 1: consensus時間を短くする
return lamb / mult
def generate_covariates(n, d, n_binary=0, p=0.5):
"""
n: the number of instances, integer
d: the dimension of the covarites, integer
binary: a float between 0 and d the represents the binary covariates
p: in binary, the probability of 1
returns (n, d+1)
"""
# pylint: disable=chained-comparison
assert n_binary >= 0 and n_binary <= d, "binary must be between 0 and d"
covariates = np.zeros((n, d + 1))
covariates[:, : d - n_binary] = random.exponential(1, size=(n, d - n_binary))
covariates[:, d - n_binary : -1] = random.binomial(1, p, size=(n, n_binary))
covariates[:, -1] = np.ones(n)
return covariates
def simulate():
runtimes = npr.choice(task_times, size=remaining_tasks)
runtimes = np.concatenate(
(current_predictions, npr.exponential(runtimes)))
schedules = []
for t in runtimes[:parallelism]:
heapq.heappush(schedules, t)
clock = 0.0
for t in runtimes[parallelism:]:
clock = heapq.heappop(schedules)
heapq.heappush(schedules, t + clock)
return max(schedules)
def sampleDiffShare(self, t, tau):
while(True):
sum_u = self.intensity(
t, skip_last_share=False) - self.intensity(t, skip_last_share=True)
# If the intensity is zero return a large time.
if sum_u < np.finfo(float).eps:
return self.T + np.finfo(float).eps
t_ = random.exponential(1.0 / sum_u)
t = t_ + t
if t > tau:
return tau
new_u = self.intensity(
t, skip_last_share=False) - self.intensity(t, skip_last_share=True)
if random.uniform() * sum_u < new_u:
return t
def sample_edges(z, out_strength, in_strength):
s_tot = max(np.sum(out_strength.value), np.sum(in_strength.value))
sample = []
for i in np.arange(len(out_strength)):
ind_out = out_strength[i].id
s_out = out_strength[i].value
for j in np.arange(len(in_strength)):
ind_in = in_strength[j].id
s_in = in_strength[j].value
if ind_out != ind_in:
p = p_fit(z, s_out, s_in)
if rng.random() < p:
w = np.float64(rng.exponential(s_out * s_in / (s_tot * p)))
sample.append((ind_out, ind_in, w))
return sample
def sample(self, skip_last_share=False):
while (True):
sum_u = self.intensity(self.t, skip_last_share=skip_last_share)
# If the intensity is zero return a large time.
if sum_u < np.finfo(float).eps:
self.t = self.T
return self.T + np.finfo(float).eps
t_ = random.exponential(1.0 / sum_u)
self.t = t_ + self.t
if self.t > self.T:
self.t = self.T
return self.T
new_u = self.intensity(self.t, skip_last_share=skip_last_share)
if random.uniform() * sum_u < new_u:
return self.t
def _SSA_single_simulation(self, final_time, time_stamp, model_dimension,
trans_number):
"""
A single SSA simulation run, returns the value of observables
:param final_time: final simulation time
:param time_stamp: time array containing time points to save
:param model_dimension: dimension of the model
:param trans_number: transitions' number
:return: the observables computed along the trajectory
"""
# tracks simulation time and state
time = 0
state = self.x0
# tracks index of the time stamp vector, to save the array
print_index = 1
x = np.zeros((len(time_stamp), model_dimension))
# save initial state
x[0, :] = self.x0
# main SSA loop
trans_code = range(trans_number)
while time < final_time:
# compute rates and total rate
rates = self.model.evaluate_rates(state)
# sanity check, to avoid negative numbers close to zero
rates[rates < 1e-14] = 0.0
total_rate = sum(rates)
# check if total rate is non zero.
if total_rate > 1e-14:
# if so, sample next time and next state and update state and time
trans_index = rnd.choice(trans_number, p=rates / total_rate)
delta_time = rnd.exponential(
1 / (self.model.system_size * total_rate))
time += delta_time
state = state + self.model.transitions[
trans_index].update.flatten() / self.model.system_size
else:
# If not, stop simulation by skipping to final time
time = final_time
# store values in the output array
while print_index < len(
time_stamp) and time_stamp[print_index] <= time:
x[print_index, :] = state
print_index += 1
# computes observables
y = self._compute_observables(x)
return y
def __init__(self, tempdir):
np.random.seed(42)
self.tmp_dir = tempdir
p = Path(self.tmp_dir)
self.ns = 100
self.nc = 10
self.nt = 5
self.ncd = 1000
np.save(p / 'spike_times.npy',
.01 * np.cumsum(nr.exponential(size=self.ns)))
np.save(p / 'spike_clusters.npy',
nr.randint(low=0, high=self.nt, size=self.ns))
shutil.copy(p / 'spike_clusters.npy', p / 'spike_templates.npy')
np.save(p / 'amplitudes.npy',
nr.uniform(low=0.5, high=1.5, size=self.ns))
np.save(p / 'channel_positions.npy', np.c_[np.arange(self.nc),
np.zeros(self.nc)])
np.save(p / 'templates.npy',
np.random.normal(size=(self.nt, 50, self.nc)))
np.save(p / 'similar_templates.npy',
np.tile(np.arange(self.nt), (self.nt, 1)))
np.save(p / 'channel_map.npy', np.c_[np.arange(self.nc)])
np.save(p / 'channel_probe.npy', np.zeros(self.nc))
_write_tsv_simple(p / 'cluster_group.tsv', 'group', {
2: 'good',
3: 'mua',
5: 'noise'
})
_write_tsv_simple(
p / 'cluster_Amplitude.tsv',
field_name='Amplitude',
data={str(n): np.random.rand() * 120
for n in np.arange(self.nt)})
with open(p / 'probes.description.txt', 'w+') as fid:
fid.writelines(['label\n'])
# Raw data
self.dat_path = p / 'rawdata.npy'
np.save(self.dat_path, np.random.normal(size=(self.ncd, self.nc)))
# LFP data.
lfdata = (100 * np.random.normal(size=(1000, self.nc))).astype(
np.int16)
with (p / 'mydata.lf.bin').open('wb') as f:
lfdata.tofile(f)
self.files = os.listdir(self.tmp_dir)
def simulateHawkesProcess(params):
"""
Input : params = (T,lambda0,alpha,beta)
T : Time Horizon of simulation.
lambda0: Base intensity.
alpha : the stretch parameter of function g.
beta : the decaying parameter of function g
"g(x) = alpha*exp(-beta*x)"
Output: jumpTimes: an array containing the jump times of Hawkes process
"""
T,lambda0,alpha,beta = params
currentInstant = 0 # the current generated instant.
numberOfInstants = 0 # the current number of jumps.
lambdaUpperBound = lambda0 # the current upper bound for lambda_t for thining algorithm
jumpTimes = [] # a list of accepted instants (jumpTimes)
while(currentInstant<T):
jumpGapWidth = npr.exponential(1/lambdaUpperBound)
currentInstant += jumpGapWidth
D = npr.uniform(0,1)
intensityOfNewPoint = lambda0 + np.exp(-beta*jumpGapWidth)*(lambdaUpperBound-lambda0)
if(lambdaUpperBound*D<=intensityOfNewPoint):
lambdaUpperBound = intensityOfNewPoint + alpha
numberOfInstants+=1
jumpTimes.append(currentInstant)
else:
lambdaUpperBound = intensityOfNewPoint
if(jumpTimes[-1]>T):
jumpTimes.pop()
return np.array(jumpTimes)
def reset_board(self):
# Create Snakes
self.master_snake = Snake(self.BOARD_SIZE, self.M)
self.enemy_snake = Snake(self.BOARD_SIZE, self.M)
self.COUNTER = 0
self.ENEMY_COUNTER = 0
# Create Board
self._state = [([[0, 0, 0, 0, 0]] * self.BOARD_SIZE)
for i in range(self.BOARD_SIZE)]
self._enemy_state = [([[0, 0, 0, 0, 0]] * self.BOARD_SIZE)
for i in range(self.BOARD_SIZE)]
self._episode_ended = False
master_init_x_coord, master_init_y_coord = self.master_snake.get_path_coords(
)
enemy_init_x_coord, enemy_init_y_coord = self.enemy_snake.get_path_coords(
)
self._state[master_init_y_coord[0]][master_init_x_coord[0]] = [
self.M, 0, self.M, 0, 0
]
self._state[enemy_init_y_coord[0]][enemy_init_x_coord[0]] = [
0, 0, 0, 0, self.M
]
self._enemy_state[master_init_y_coord[0]][master_init_x_coord[0]] = [
0, 0, 0, 0, self.M
]
self._enemy_state[enemy_init_y_coord[0]][enemy_init_x_coord[0]] = [
self.M, 0, self.M, 0, 0
]
# Special case for food spawn 0
if (self.FOOD_SPAWN_MODE == 0):
self.food_spawn_arr = np.ceil(exponential(5, size=100))
self.current_food_spawn = 0 #current index of above array
self.food_timer = 0
# Special case for food spawn 1
elif (self.FOOD_SPAWN_MODE == 1):
self.foodspawn_assist()
# Set if snake ate during previous turn, which is true for first spawn
self.master_snake.set_just_eaten(True)
self.enemy_snake.set_just_eaten(True)
self.__dict__.pop('ENEMY_POLICY', None)
self.ENEMY_POLICY = self.MASTER_ENEMY_POLICY
def cindep(n, d):
beta = 10
p = 0.5
exp_dist = rnd.exponential(scale=beta, size=n)
pois_dist = list()
binom_dist = list()
for itr in exp_dist:
pois = rnd.poisson(itr, size=1)[0]
pois_dist.append(pois)
binom_dist.append(rnd.binomial(pois, p, size=1)[0])
dat = {'exp': exp_dist, 'binom': binom_dist, 'pois': pois_dist}
for itr in range(d - 1):
dat[str(itr)] = rnd.normal(0, 1, n)
df = pd.DataFrame(data=dat)
info = 0
name = 'Variables Mixed and Conditionally Independent'
return df, info, name
def eulerMascheroni():
gamma = 0
gamma1 = 0
beta = uniform(5, 100)
A = []
while True:
k = int(exponential(beta)) + 1
print(k, gamma, gamma1, len(A))
if k in A: pass
else:
gamma = gamma + 1 / k
A.append(k)
if len(A) >= 250: break
gamma1 = gamma
n = max(A)
gamma = gamma - log(n)
return (n, gamma)
def getoneimg(self):
self.img[:, :] = 20.0
# get points
Np = rd.poisson(self.nnp)
pti = rd.randint(0, 1000, Np)
#xp = self.xps[pti]
#yp = self.yps[pti]
xp = self.xcntr
yp = self.ycntr
zp = self.zps[pti]
#Ip = rd.poisson(self.iip,Np) #[self.iip]
Ip = rd.exponential(self.iip, Np)
# create psfs
for m in range(Np):
self.addpsf(xp, yp, zp[m], Ip[m])
# noise
self.img = rd.poisson(self.img)
def confirm(block_id, chunk_ids):
print("Confirming block", block_id, "with chunks:", chunk_ids)
if BETA:
time.sleep(random.exponential(BETA))
url = "{}/api/block/{}".format(config.BASE_URL, block_id)
owner = config.OWNER
r = requests.post(url,
json={
'block_id': block_id,
'chunks': chunk_ids,
'owner': owner
})
if r.status_code == 200:
print("Confirmed:", block_id)
else:
print("Rejected:", block_id, r.status_code, r.text)
return r.status_code
def createPackets(self, cs):
'''You must complete this method. This method generates and creates packets as per the
arrival rate distribution defined'''
i = 0
while True:
##
if args.type == 'MM1' or args.type == 'MM2':
yield hold, self, exponential(Parameters.arrivals_poisson)
##
else:
yield hold, self, uniform(Parameters.interarrivalTimeMin,
Parameters.interarrivalTimeMax)
packet_name = "Packet " + str(i)
p = Packet(name=packet_name)
activate(p, p.behavior_of_single_packet(cs))
i = i + 1
def build_chunglu_graph(N,
exp_val,
fn_edges=[
lambda G, x, y: npr.exponential(2),
lambda G, x, y: np.abs(npr.normal(0, 1))
],
directed=True,
self=False):
A = nx.expected_degree_graph(
[np.round(v) for v in truncated_power_law(N, exp_val)], selfloops=self)
A.remove_nodes_from(list(nx.isolates(A)))
A = nx.relabel_nodes(A,
{k: v
for k, v in zip(A.nodes, range(len(A.nodes)))})
A = nx.DiGraph(A)
return networkx_wrapper(A, self=self, directed=directed, fn_edges=fn_edges)
def generate_usage_log_data(Model, n=100):
_names = ['andy', 'betty', 'bobby', 'timmy', 'sue']
_imagetypes = ['Python', 'Python+R']
_numgpus = [0, 1, 2, 3, 4]
containers = []
for i in range(n):
td_start = timedelta(days=i % 30, hours=random.randint(0, 23))
start = datetime.utcnow() - td_start
instance = Model(id=secrets.token_hex(32),
username=random.choice(_names),
image_type=random.choice(_imagetypes),
num_gpus=random.choice(_numgpus),
start_time=start,
stop_time=start + timedelta(hours=exponential(8)))
containers.append(instance)
return containers
def play(n, hist, lw, lc, y):
# Needed to access the global variables
global sumlw, games
games += 1
# On the first game, we can't calculate a mean of previous wins, so just
# guess zero
if (games == 0):
sumlw = lw
return 1
# On subsequent games, calculate the mean of the previous wins, rounded to
# the nearest integer
sumlw += lw
mean_lw = sumlw / games
#return the nearest int from an exponential distribution sample with mean of all winners in previous rounds
return int(nprnd.exponential(mean_lw) + 0.5)
def fit_sample(p_f, param, out_strength, in_strength):
""" Sample from the fitness model ensemble.
"""
s_tot = np.sum(out_strength)
msg = 'Sum of in/out strengths not the same.'
assert np.abs(1 - np.sum(in_strength)/s_tot) < 1e-6, msg
sample = []
for i in np.arange(len(out_strength)):
s_out = out_strength[i]
for j in np.arange(len(in_strength)):
s_in = in_strength[j]
if i != j:
p = p_f(param, s_out, s_in)
if rng.random() < p:
w = np.float64(rng.exponential(s_out*s_in/(s_tot*p)))
sample.append((i, j, w))
return sample
def put_arrival(self, router_idx, packet_idx):
"""
Put a MType.ARRIVAL event into router event queue
:param router_idx: index of a router in which event should be put
:param packet_idx: index of a packet
"""
if router_idx == 0: # if it is the first router we have to make a new packet
t = self.time + exponential(1/self.lambd)
packet = MopsPacket(len(self.packet_list), len(self.routers))
packet.times[router_idx][MType.ARRIVAL] = t
self.packet_list.append(packet)
e = MopsEvent(t, event_type=MType.ARRIVAL, packet_idx=packet.packet_idx, router_idx=router_idx)
else: # otherwise just send existing packet to the next router
t = self.packet_list[packet_idx].times[router_idx - 1][MType.END_SERVICE]
e = MopsEvent(t, event_type=MType.ARRIVAL, packet_idx=packet_idx, router_idx=router_idx)
self.packet_list[packet_idx].times[router_idx][MType.ARRIVAL] = t
self.event_queue.put((t, e))
def sim_occurrences(tree, r):
occurrences = {}
for i in tree.iternodes():
if i.istip:
cur_length = i.length
occurrences[i.label] = []
i.old_length = i.length
while (cur_length > 0):
cur_length -= exponential(r)
cur_time = i.height + cur_length
if cur_length > 0:
occurrences[i.label].append(cur_time)
if len(occurrences[i.label]) == 0:
occurrences[i.label].append(i.height)
elif i.height == 0.:
occurrences[i.label].append(i.height)
i.length = i.old_length
return occurrences
def gen_rnd_sequence(N_sekv, N_realiz, tip, mean=0, std=1):
if tip == 'uniform':
return rnd.uniform(mean - std * sqrt(3), mean + std * sqrt(3),
(N_realiz, N_sekv))
elif tip == 'exponential':
return rnd.exponential(std, (N_realiz, N_sekv))
elif tip == 'normal':
return rnd.normal(mean, std, (N_realiz, N_sekv))
elif tip == 'normal_converging_var':
X_n = empty((N_realiz, N_sekv))
for j in range(N_sekv):
X_n[:, j] = rnd.normal(mean, std * (1 - exp(-(j + 1))), N_realiz)
return X_n
elif tip == 'normal_diverging_var':
X_n = empty((N_realiz, N_sekv))
for j in range(N_sekv):
X_n[:, j] = rnd.normal(mean, std * (j + 1), N_realiz)
return X_n
def gen_samples(data, s, samples, num):
y = np.zeros(samples)
a = np.random.randint(4, samples - (s + 4))
x = data
signal_std = x.std()
noize_std = signal_std / np.power(10, d / 20)
a = (noize_std * np.sqrt(12)) / 2
if num == 1:
n = (r.uniform(-a, a, size=s) + r.normal(0, noize_std, size=s) +
r.exponential(noize_std, size=s))
x[a:a + s] = x[a] + n
y[a:a + s] = 1
return x, y
def arrival():
"""
Simulates the arrival of a car.
Cars arrive according to a Poisson process wite rate r.
The time between subsequent arrivals are i.i.d. exponential random variables with mean 1.0 / r
"""
global arrival_count, env, light, queue
while True:
arrival_count += 1
if light == 'red' or len(queue): # new car joins queue
queue.append((arrival_count, env.now))
print("Car #%d arrived and joined the queue at position %d at time "
"%.3f." % (arrival_count, len(queue), env.now))
else:
print("Car #%d arrived to a green light with no cars waiting at time "
"%.3f." % (arrival_count, env.now))
W_stats.count+= 1
yield env.timeout( random.exponential(1.0 / ARRIVAL_RATE)) # schedule next arrival
def setUp(self):
self.tmp_dir = tempfile.TemporaryDirectory()
p = Path(self.tmp_dir.name)
self.ns = 100
self.nc = 10
self.nt = 5
np.save(p / 'spike_times.npy', np.cumsum(nr.exponential(size=self.ns)))
np.save(p / 'spike_clusters.npy',
nr.randint(low=0, high=10, size=self.ns))
np.save(p / 'amplitudes.npy',
nr.uniform(low=0.5, high=1.5, size=self.ns))
np.save(p / 'channel_positions.npy', np.c_[np.arange(self.nc),
np.zeros(self.nc)])
np.save(p / 'templates.npy',
np.random.normal(size=(self.nt, 50, self.nc)))
np.save(p / 'channel_map.npy', np.c_[np.arange(self.nc)])
np.save(p / 'rawdata.npy', np.random.normal(size=(1000, self.nc)))
self.files = os.listdir(self.tmp_dir.name)
def simulate_time_rescaling(runtime,
kernel=functions.kernel_zhao,
p=functions.infectious_rate_tweets,
dt=0.01,
follower_pool=None,
int_fol_cnt=10000,
follower_mean=200,
split=0.015):
"""
Simulates time dependent Hawkes process using time rescaling.
Follower counts can be taken from a pool passed to the function or generated.
:param runtime: time to simulate (in hours)
:param kernel: kernel function
:param p: infectious rate function
:param dt: integral evaluation interval size
:param follower_pool: follower counts used for simulation, makes last 3 parameters void
:param int_fol_cnt: initial follower value
:param follower_mean: mean of generated followers
:param split: percentage for when the follower should be generated very big
:return: list of event tuples
"""
events = [(0, int_fol_cnt)]
ti = 0
print_cnt = 0
while 0 <= ti < runtime and len(events) < 4500:
X = rand.exponential()
tj = solve_integral(ti, X, kernel, p, events, dt, runtime)
if follower_pool is not None:
fol = rand.choice(follower_pool)
else:
fol = rand_followers_extended(int_fol_cnt, follower_mean, split)
if tj > 0:
events.append((tj, fol))
ti = tj
if print_cnt % 100 == 0:
print("Simulating [%f%%]..." % (ti / runtime * 100), flush=True)
print_cnt += 1
print("\nOver %d events generated" % len(events))
return events
