File size: 4,331 Bytes
dee9fba | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 | """Benchmark batching="auto" on high number of fast tasks
The goal of this script is to study the behavior of the batch_size='auto'
and in particular the impact of the default value of the
joblib.parallel.MIN_IDEAL_BATCH_DURATION constant.
"""
# Author: Olivier Grisel
# License: BSD 3 clause
import numpy as np
import time
import tempfile
from pprint import pprint
from joblib import Parallel, delayed
from joblib._parallel_backends import AutoBatchingMixin
def sleep_noop(duration, input_data, output_data_size):
"""Noop function to emulate real computation.
Simulate CPU time with by sleeping duration.
Induce overhead by accepting (and ignoring) any amount of data as input
and allocating a requested amount of data.
"""
time.sleep(duration)
if output_data_size:
return np.ones(output_data_size, dtype=np.byte)
def bench_short_tasks(task_times, n_jobs=2, batch_size="auto",
pre_dispatch="2*n_jobs", verbose=True,
input_data_size=0, output_data_size=0, backend=None,
memmap_input=False):
with tempfile.NamedTemporaryFile() as temp_file:
if input_data_size:
# Generate some input data with the required size
if memmap_input:
temp_file.close()
input_data = np.memmap(temp_file.name, shape=input_data_size,
dtype=np.byte, mode='w+')
input_data[:] = 1
else:
input_data = np.ones(input_data_size, dtype=np.byte)
else:
input_data = None
t0 = time.time()
p = Parallel(n_jobs=n_jobs, verbose=verbose, pre_dispatch=pre_dispatch,
batch_size=batch_size, backend=backend)
p(delayed(sleep_noop)(max(t, 0), input_data, output_data_size)
for t in task_times)
duration = time.time() - t0
effective_batch_size = getattr(p._backend, '_effective_batch_size',
p.batch_size)
print('Completed {} tasks in {:3f}s, final batch_size={}\n'.format(
len(task_times), duration, effective_batch_size))
return duration, effective_batch_size
if __name__ == "__main__":
bench_parameters = dict(
# batch_size=200, # batch_size='auto' by default
# memmap_input=True, # if True manually memmap input out of timing
# backend='threading', # backend='multiprocessing' by default
# pre_dispatch='n_jobs', # pre_dispatch="2*n_jobs" by default
input_data_size=int(2e7), # input data size in bytes
output_data_size=int(1e5), # output data size in bytes
n_jobs=2,
verbose=10,
)
print("Common benchmark parameters:")
pprint(bench_parameters)
AutoBatchingMixin.MIN_IDEAL_BATCH_DURATION = 0.2
AutoBatchingMixin.MAX_IDEAL_BATCH_DURATION = 2
# First pair of benchmarks to check that the auto-batching strategy is
# stable (do not change the batch size too often) in the presence of large
# variance while still be comparable to the equivalent load without
# variance
print('# high variance, no trend')
# censored gaussian distribution
high_variance = np.random.normal(loc=0.000001, scale=0.001, size=5000)
high_variance[high_variance < 0] = 0
bench_short_tasks(high_variance, **bench_parameters)
print('# low variance, no trend')
low_variance = np.empty_like(high_variance)
low_variance[:] = np.mean(high_variance)
bench_short_tasks(low_variance, **bench_parameters)
# Second pair of benchmarks: one has a cycling task duration pattern that
# the auto batching feature should be able to roughly track. We use an even
# power of cos to get only positive task durations with a majority close to
# zero (only data transfer overhead). The shuffle variant should not
# oscillate too much and still approximately have the same total run time.
print('# cyclic trend')
slow_time = 0.1
positive_wave = np.cos(np.linspace(1, 4 * np.pi, 300)) ** 8
cyclic = positive_wave * slow_time
bench_short_tasks(cyclic, **bench_parameters)
print("shuffling of the previous benchmark: same mean and variance")
np.random.shuffle(cyclic)
bench_short_tasks(cyclic, **bench_parameters)
|