Overlapping on/off sources

Transcription

1 Overlapping on/off sources A few helper functions to more easily deal with arrival processes In [1]: from itertools import cycle, islice def roundrobin(*iterables): "roundrobin('abc', 'D', 'EF') --> A D E B F C" # Recipe credited to George Sakkis pending = len(iterables) nexts = cycle(iter(it). next for it in iterables) while pending: try: for next in nexts: yield next() except StopIteration: pending -= 1 nexts = cycle(islice(nexts, pending)) def plusminus1(iterable): "plusminus1('abc') --> (A, +1), (B, -1), (C, +1)" it = iter(iterable) suffix = +1 while True: val = next(it) yield((val, suffix)) suffix *= -1 Actual generation of traces It takes separate random variables for interarrival times (=off time) and duration of an on period. And two obvious parameters. The trick is to do separate startstop durations per source, and then simple overlap these traces. These overlapped traces then have to be turned into a count-process style representation, where we also decrement count when a process switches to off (that's what we need the -1 for).

2 In [2]: from itertools import accumulate import numpy as np from pprint import pprint as pp num_sources = 100 num_samples = def onoffsources(iatrv, lengthrv, samples=num_samples, sources=num_sources): # generate IATs: when does the source become active again after it turned off? iats = [ iatrv(size=samples) for x in range(sources)] # pp(iats) # generate lengths, also exponential lengths = [lengthrv(size=samples) for x in range(sources)] # pp(lengths) e # merge the two into each other, giving us on/off points in tim startstop = [list(plusminus1(accumulate(roundrobin(i, l)))) for i, l in zip(iats, lengths)] # pp(startstop) # and overlap all of the individual sources merged = sorted([ev for l in startstop for ev in l]) # pp(merged) counts = accumulate((c[1] for c in merged)) # pp(list(counts)) countproc = (list((ev[0] for ev in merged)), list(counts)) # pp(countproc) return countproc Examples Exponential on and off durations This needs a bit of fiddling to get a function with the correct signature into the onoffsources function. Thankfully, Python is a functional language so we can easily adapt the np.random.exponential function by currying. In [3]: expexpcp = onoffsources(np.random.exponential, lambda size: np.random.exponential(scale=1, size=size),) # pp(expexpcp)

3 In [4]: %matplotlib notebook from matplotlib import pyplot as plt fig = plt.figure() plt.plot(expexpcp[0], expexpcp[1], '.') plt.show() Exponential interarrival, lognormal duration we use the lomax distribution from Scipy, better documented version of a Pareto distribution.

4 In [5]: # ordinary pareto from numpy: # expparetocp = onoffsources(np.random.exponential, # lambda size: np.random.pareto(a=0.5, s ize=size),) # pp(expparetocp) # lomax from Scipy, better documentation: from scipy.stats import lomax lmrv = lomax(1.5) expparetocp = onoffsources(np.random.exponential, lambda size: [x/lmrv.mean() for x in lm RV.rvs(size=size)],) # pp(expparetocp) fig = plt.figure() plt.plot(expparetocp[0], expparetocp[1], 'r.') plt.show() Aggregation We first turn the sequence of times into fixed intervals. That eases aggregation later on. In [6]: def fixedintervals(countprocess, interval): """Turn the discrete-time process into fixed intervals""" current_start = 0

5 current_end = current_start + interval current_area = 0 current_val = 0 t, val = next(countprocess[0]), next(countprocess[1]) while True: while t < current_end: current_area += () def groupcp(countprocess, interval): alldata = [] data = [(0, 0)] endtime = countprocess[0][-1] interval_start = 0 previous_val = 0 for t, val in zip(countprocess[0], countprocess[1]): if t < interval_start + interval: data.append((t, val)) previous_val = val else: data.append((interval_start + interval, previous_val)) alldata.append(data) data = [(interval_start + interval, previous_val)] interval_start += interval return alldata def area(fixedcp): alldata = [] for intcp in fixedcp: data = [] for a, b in zip(intcp[:-1], intcp[1:]): data.append((b[0] - a[0], a[1])) alldata.append(data) return alldata def averagearea(areacp): alldata = [] for intdata in areacp: sumval = sum((x[0] * x[1] for x in intdata )) alldata.append(sumval) return alldata def aggregate(countprocess, aggregationlevel=2): return [ sum(countprocess[i:i+aggregationlevel])/aggregationlev el for i in range(0, len(countprocess), aggregationlevel)] def recursiveaggregate(countprocess, maxaggregration=5): aggregates = [countprocess, ] for i in range(maxaggregration): aggregates.append(aggregate(aggregates[i]))

6 return aggregates In [7]: def count_and_aggregate(cp): fixed = groupcp(cp, 1) # pp(fixedexpexp) ar = area(fixed) # pp(areaexpexp) av = averagearea(ar) # pp(avexpexp) # pp(aggregate(avexpexp)) agg = recursiveaggregate(av) # pp(aggexpexp) return agg aggexpexp = count_and_aggregate(expexpcp) In [8]: def plot_aggregates(agg): f, ax = plt.subplots(len(agg)) for i, trace in enumerate(agg): ax[i].plot(trace) plt.show() plot_aggregates(aggexpexp)

7 In [9]: aggexppareto = count_and_aggregate(expparetocp) plot_aggregates(aggexppareto) Comput variances Of aggregation levels, after removing initial and final tranients (very rougly)

8 In [10]: stdexp = [np.std(trace[:int(0.9*len(trace))]) for trace in aggexpex p] stdpar = [np.std(trace[:int(0.9*len(trace))]) for trace in aggexppa reto] plt.figure() plt.plot(stdexp, 'b', label="exponential service times") plt.plot(stdpar, 'r', label="pareto service times") plt.title('standard deviation of On/Off sources with different serv ice times') plt.xlabel("aggregation level") plt.ylabel("standard deviation") plt.legend() plt.show()