The function took 5.08 s to compute.
│ │ │ │ +The function took 5.14 s to compute.
│ │ │ │
│ │ │ │ The transformed data are:
│ │ │ │ [ 0.49671415 -0.1382643 0.64768854 1.52302986 -0.23415337 -0.23413696
│ │ │ │ 1.57921282 0.76743473 -0.46947439 0.54256004]
│ │ │ │
│ │ │ │
│ │ │ │ start = time.time()
│ │ │ │ data_trans = transformer.transform(data)
│ │ │ │ end = time.time()
│ │ │ │
│ │ │ │ print('\nThe function took {:.2f} s to compute.'.format(end - start))
│ │ │ │ print('\nThe transformed data are:\n {}'.format(data_trans))
│ │ │ │
│ │ │ │
│ │ │ │ -The function took 0.03 s to compute.
│ │ │ │ +The function took 0.05 s to compute.
│ │ │ │
│ │ │ │ The transformed data are:
│ │ │ │ [ 0.49671415 -0.1382643 0.64768854 1.52302986 -0.23415337 -0.23413696
│ │ │ │ 1.57921282 0.76743473 -0.46947439 0.54256004]
│ │ │ │
│ │ │ │
│ │ │ │ As expected, the second call to the transform method load the results
│ │ │ │ which have been cached.
│ │ │ │
│ │ │ │
│ │ │ │ Clean up cache directory¶
│ │ │ │ memory.clear(warn=False)
│ │ │ │
│ │ │ │
│ │ │ │ -Total running time of the script: (0 minutes 15.250 seconds)
│ │ │ │ +Total running time of the script: (0 minutes 15.457 seconds)
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -49,29 +49,29 @@
│ │ │ │ │ _c_o_s_t_l_y___c_o_m_p_u_t_e___c_a_c_h_e_d = _m_e_m_o_r_y_._c_a_c_h_e(_c_o_s_t_l_y___c_o_m_p_u_t_e___c_a_c_h_e_d)
│ │ │ │ │ _s_t_a_r_t = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ _d_a_t_a___t_r_a_n_s = _c_o_s_t_l_y___c_o_m_p_u_t_e___c_a_c_h_e_d(_d_a_t_a)
│ │ │ │ │ _e_n_d = _t_i_m_e_._t_i_m_e()
│ │ │ │ │
│ │ │ │ │ print('\nThe function took {:.2f} s to compute.'.format(_e_n_d - _s_t_a_r_t))
│ │ │ │ │ print('\nThe transformed data are:\n {}'.format(_d_a_t_a___t_r_a_n_s))
│ │ │ │ │ -The function took 5.07 s to compute.
│ │ │ │ │ +The function took 5.14 s to compute.
│ │ │ │ │
│ │ │ │ │ The transformed data are:
│ │ │ │ │ [ 0.49671415 -0.1382643 0.64768854 1.52302986 -0.23415337 -0.23413696
│ │ │ │ │ 1.57921282 0.76743473 -0.46947439 0.54256004]
│ │ │ │ │ At the first call, the results will be cached. Therefore, the computation time
│ │ │ │ │ corresponds to the time to compute the results plus the time to dump the
│ │ │ │ │ results into the disk.
│ │ │ │ │ _s_t_a_r_t = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ _d_a_t_a___t_r_a_n_s = _c_o_s_t_l_y___c_o_m_p_u_t_e___c_a_c_h_e_d(_d_a_t_a)
│ │ │ │ │ _e_n_d = _t_i_m_e_._t_i_m_e()
│ │ │ │ │
│ │ │ │ │ print('\nThe function took {:.2f} s to compute.'.format(_e_n_d - _s_t_a_r_t))
│ │ │ │ │ print('\nThe transformed data are:\n {}'.format(_d_a_t_a___t_r_a_n_s))
│ │ │ │ │ -The function took 0.03 s to compute.
│ │ │ │ │ +The function took 0.05 s to compute.
│ │ │ │ │
│ │ │ │ │ The transformed data are:
│ │ │ │ │ [ 0.49671415 -0.1382643 0.64768854 1.52302986 -0.23415337 -0.23413696
│ │ │ │ │ 1.57921282 0.76743473 -0.46947439 0.54256004]
│ │ │ │ │ At the second call, the computation time is largely reduced since the results
│ │ │ │ │ are obtained by loading the data previously dumped to the disk instead of
│ │ │ │ │ recomputing the results.
│ │ │ │ │ @@ -99,35 +99,35 @@
│ │ │ │ │ transformer = Algorithm()
│ │ │ │ │ _s_t_a_r_t = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ _d_a_t_a___t_r_a_n_s = transformer.transform(_d_a_t_a)
│ │ │ │ │ _e_n_d = _t_i_m_e_._t_i_m_e()
│ │ │ │ │
│ │ │ │ │ print('\nThe function took {:.2f} s to compute.'.format(_e_n_d - _s_t_a_r_t))
│ │ │ │ │ print('\nThe transformed data are:\n {}'.format(_d_a_t_a___t_r_a_n_s))
│ │ │ │ │ -The function took 5.08 s to compute.
│ │ │ │ │ +The function took 5.14 s to compute.
│ │ │ │ │
│ │ │ │ │ The transformed data are:
│ │ │ │ │ [ 0.49671415 -0.1382643 0.64768854 1.52302986 -0.23415337 -0.23413696
│ │ │ │ │ 1.57921282 0.76743473 -0.46947439 0.54256004]
│ │ │ │ │ _s_t_a_r_t = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ _d_a_t_a___t_r_a_n_s = transformer.transform(_d_a_t_a)
│ │ │ │ │ _e_n_d = _t_i_m_e_._t_i_m_e()
│ │ │ │ │
│ │ │ │ │ print('\nThe function took {:.2f} s to compute.'.format(_e_n_d - _s_t_a_r_t))
│ │ │ │ │ print('\nThe transformed data are:\n {}'.format(_d_a_t_a___t_r_a_n_s))
│ │ │ │ │ -The function took 0.03 s to compute.
│ │ │ │ │ +The function took 0.05 s to compute.
│ │ │ │ │
│ │ │ │ │ The transformed data are:
│ │ │ │ │ [ 0.49671415 -0.1382643 0.64768854 1.52302986 -0.23415337 -0.23413696
│ │ │ │ │ 1.57921282 0.76743473 -0.46947439 0.54256004]
│ │ │ │ │ As expected, the second call to the transform method load the results which
│ │ │ │ │ have been cached.
│ │ │ │ │ ********** CClleeaann uupp ccaacchhee ddiirreeccttoorryy_?¶ **********
│ │ │ │ │ _m_e_m_o_r_y_._c_l_e_a_r(warn=False)
│ │ │ │ │ -TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 15.250 seconds)
│ │ │ │ │ +TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 15.457 seconds)
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _J_u_p_y_t_e_r_ _n_o_t_e_b_o_o_k_:_ _m_e_m_o_r_y___b_a_s_i_c___u_s_a_g_e_._i_p_y_n_b
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _P_y_t_h_o_n_ _s_o_u_r_c_e_ _c_o_d_e_:_ _m_e_m_o_r_y___b_a_s_i_c___u_s_a_g_e_._p_y
│ │ │ │ │ _G_a_l_l_e_r_y_ _g_e_n_e_r_a_t_e_d_ _b_y_ _S_p_h_i_n_x_-_G_a_l_l_e_r_y
│ │ │ │ │ _[_L_o_g_o_]
│ │ │ │ │ ******** NNaavviiggaattiioonn ********
│ │ │ │ │ User manual
│ │ │ │ │ * _W_h_y_ _j_o_b_l_i_b_:_ _p_r_o_j_e_c_t_ _g_o_a_l_s
│ │ │ ├── ./usr/share/doc/python-joblib-doc/html/auto_examples/nested_parallel_memory.html
│ │ │ │ @@ -118,15 +118,15 @@
│ │ │ │
│ │ │ │ print('\nFirst round - caching the data')
│ │ │ │ print('Elapsed time for the entire processing: {:.2f} s'
│ │ │ │ .format(stop - start))
│ │ │ │
│ │ │ │
│ │ │ │ First round - caching the data
│ │ │ │ -Elapsed time for the entire processing: 4.69 s
│ │ │ │ +Elapsed time for the entire processing: 4.71 s
│ │ │ │
│ │ │ │
│ │ │ │ By using 2 workers, the parallel processing gives a x2 speed-up compared to
│ │ │ │ the sequential case. By executing again the same process, the intermediate
│ │ │ │ results obtained by calling costly_compute_cached will be loaded from the
│ │ │ │ cache instead of executing the function.
│ │ │ │ start = time.time()
│ │ │ │ @@ -178,15 +178,15 @@
│ │ │ │ results from the cache.
│ │ │ │
│ │ │ │
│ │ │ │ Clean-up the cache folder¶
│ │ │ │ memory.clear(warn=False)
│ │ │ │
│ │ │ │
│ │ │ │ -Total running time of the script: (0 minutes 12.785 seconds)
│ │ │ │ +Total running time of the script: (0 minutes 12.818 seconds)
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -59,15 +59,15 @@
│ │ │ │ │ for col in range(_d_a_t_a_._s_h_a_p_e[1]))
│ │ │ │ │ _s_t_o_p = _t_i_m_e_._t_i_m_e()
│ │ │ │ │
│ │ │ │ │ print('\nFirst round - caching the data')
│ │ │ │ │ print('Elapsed time for the entire processing: {:.2f} s'
│ │ │ │ │ .format(_s_t_o_p - _s_t_a_r_t))
│ │ │ │ │ First round - caching the data
│ │ │ │ │ -Elapsed time for the entire processing: 4.69 s
│ │ │ │ │ +Elapsed time for the entire processing: 4.71 s
│ │ │ │ │ By using 2 workers, the parallel processing gives a x2 speed-up compared to the
│ │ │ │ │ sequential case. By executing again the same process, the intermediate results
│ │ │ │ │ obtained by calling costly_compute_cached will be loaded from the cache instead
│ │ │ │ │ of executing the function.
│ │ │ │ │ _s_t_a_r_t = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ _r_e_s_u_l_t_s = _P_a_r_a_l_l_e_l(n_jobs=2)(
│ │ │ │ │ _d_e_l_a_y_e_d(data_processing_mean_using_cache)(_d_a_t_a, col)
│ │ │ │ │ @@ -100,15 +100,15 @@
│ │ │ │ │ .format(_s_t_o_p - _s_t_a_r_t))
│ │ │ │ │ Reusing intermediate checkpoints
│ │ │ │ │ Elapsed time for the entire processing: 0.04 s
│ │ │ │ │ The processing time only corresponds to the execution of the max function. The
│ │ │ │ │ internal call to costly_compute_cached is reloading the results from the cache.
│ │ │ │ │ ********** CClleeaann--uupp tthhee ccaacchhee ffoollddeerr_?¶ **********
│ │ │ │ │ _m_e_m_o_r_y_._c_l_e_a_r(warn=False)
│ │ │ │ │ -TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 12.785 seconds)
│ │ │ │ │ +TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 12.818 seconds)
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _J_u_p_y_t_e_r_ _n_o_t_e_b_o_o_k_:_ _n_e_s_t_e_d___p_a_r_a_l_l_e_l___m_e_m_o_r_y_._i_p_y_n_b
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _P_y_t_h_o_n_ _s_o_u_r_c_e_ _c_o_d_e_:_ _n_e_s_t_e_d___p_a_r_a_l_l_e_l___m_e_m_o_r_y_._p_y
│ │ │ │ │ _G_a_l_l_e_r_y_ _g_e_n_e_r_a_t_e_d_ _b_y_ _S_p_h_i_n_x_-_G_a_l_l_e_r_y
│ │ │ │ │ _[_L_o_g_o_]
│ │ │ │ │ ******** NNaavviiggaattiioonn ********
│ │ │ │ │ User manual
│ │ │ │ │ * _W_h_y_ _j_o_b_l_i_b_:_ _p_r_o_j_e_c_t_ _g_o_a_l_s
│ │ │ ├── ./usr/share/doc/python-joblib-doc/html/auto_examples/parallel_generator.html
│ │ │ │ @@ -143,15 +143,15 @@
│ │ │ │ peak = max(monitor.memory_buffer) / 1e9
│ │ │ │ print(f"Peak memory usage: {peak:.2f}GB")
│ │ │ │
│ │ │ │
│ │ │ │ Running tasks with return_as='list'...
│ │ │ │ Accumulate results:......................................................................................................................................................
│ │ │ │ All tasks completed and reduced successfully.
│ │ │ │ -Peak memory usage: 2.46GB
│ │ │ │ +Peak memory usage: 2.44GB
│ │ │ │
│ │ │ │
│ │ │ │ If we use return_as="generator", res is simply a generator on the
│ │ │ │ results that are ready. Here we consume the results as soon as they arrive
│ │ │ │ with the accumulator_sum and once they have been used, they are collected
│ │ │ │ by the gc. The memory footprint is thus reduced, typically around 300MB.
│ │ │ │ monitor_gen = MemoryMonitor()
│ │ │ │ @@ -169,15 +169,15 @@
│ │ │ │ peak = max(monitor_gen.memory_buffer) / 1e6
│ │ │ │ print(f"Peak memory usage: {peak:.2f}MB")
│ │ │ │
│ │ │ │
│ │ │ │ Create result generator with return_as='generator'...
│ │ │ │ Accumulate results:......................................................................................................................................................
│ │ │ │ All tasks completed and reduced successfully.
│ │ │ │ -Peak memory usage: 222.22MB
│ │ │ │ +Peak memory usage: 205.37MB
│ │ │ │
│ │ │ │
│ │ │ │ We can then report the memory usage accross time of the two runs using the
│ │ │ │ MemoryMonitor.
│ │ │ │ In the first case, as the results accumulate in res, the memory grows
│ │ │ │ linearly and it is freed once the accumulator_sum function finishes.
│ │ │ │ In the second case, the results are processed by the accumulator as soon as
│ │ │ │ @@ -200,15 +200,15 @@
│ │ │ │ plt.show()
│ │ │ │
│ │ │ │
│ │ │ │ 
It is important to note that with return_as="generator", the results are
│ │ │ │ still accumulated in RAM after computation. But as we asynchronously process
│ │ │ │ them, they can be freed sooner. However, if the generator is not consumed
│ │ │ │ the memory still grows linearly.
│ │ │ │ -Total running time of the script: (0 minutes 21.482 seconds)
│ │ │ │ +Total running time of the script: (0 minutes 29.052 seconds)
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -90,15 +90,15 @@
│ │ │ │ │ _m_o_n_i_t_o_r_._j_o_i_n()
│ │ │ │ │ _p_e_a_k = max(_m_o_n_i_t_o_r_._m_e_m_o_r_y___b_u_f_f_e_r) / 1e9
│ │ │ │ │ print(f"Peak memory usage: {_p_e_a_k:.2f}GB")
│ │ │ │ │ Running tasks with return_as='list'...
│ │ │ │ │ Accumulate
│ │ │ │ │ results:......................................................................................................................................................
│ │ │ │ │ All tasks completed and reduced successfully.
│ │ │ │ │ -Peak memory usage: 2.46GB
│ │ │ │ │ +Peak memory usage: 2.44GB
│ │ │ │ │ If we use return_as="generator", res is simply a generator on the results that
│ │ │ │ │ are ready. Here we consume the results as soon as they arrive with the
│ │ │ │ │ accumulator_sum and once they have been used, they are collected by the gc. The
│ │ │ │ │ memory footprint is thus reduced, typically around 300MB.
│ │ │ │ │ monitor_gen = _M_e_m_o_r_y_M_o_n_i_t_o_r()
│ │ │ │ │ print("Create result generator with return_as='generator'...")
│ │ │ │ │ res = _P_a_r_a_l_l_e_l(n_jobs=2, return_as="generator")(
│ │ │ │ │ @@ -113,15 +113,15 @@
│ │ │ │ │ _m_o_n_i_t_o_r___g_e_n_._j_o_i_n()
│ │ │ │ │ _p_e_a_k = max(_m_o_n_i_t_o_r___g_e_n_._m_e_m_o_r_y___b_u_f_f_e_r) / 1e6
│ │ │ │ │ print(f"Peak memory usage: {_p_e_a_k:.2f}MB")
│ │ │ │ │ Create result generator with return_as='generator'...
│ │ │ │ │ Accumulate
│ │ │ │ │ results:......................................................................................................................................................
│ │ │ │ │ All tasks completed and reduced successfully.
│ │ │ │ │ -Peak memory usage: 222.22MB
│ │ │ │ │ +Peak memory usage: 205.37MB
│ │ │ │ │ We can then report the memory usage accross time of the two runs using the
│ │ │ │ │ MemoryMonitor.
│ │ │ │ │ In the first case, as the results accumulate in res, the memory grows linearly
│ │ │ │ │ and it is freed once the accumulator_sum function finishes.
│ │ │ │ │ In the second case, the results are processed by the accumulator as soon as
│ │ │ │ │ they arrive, and the memory does not need to be able to contain all the
│ │ │ │ │ results.
│ │ │ │ │ @@ -141,15 +141,15 @@
│ │ │ │ │ plt.legend()
│ │ │ │ │ plt.show()
│ │ │ │ │ [parallel generator]
│ │ │ │ │ It is important to note that with return_as="generator", the results are still
│ │ │ │ │ accumulated in RAM after computation. But as we asynchronously process them,
│ │ │ │ │ they can be freed sooner. However, if the generator is not consumed the memory
│ │ │ │ │ still grows linearly.
│ │ │ │ │ -TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 21.482 seconds)
│ │ │ │ │ +TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 29.052 seconds)
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _J_u_p_y_t_e_r_ _n_o_t_e_b_o_o_k_:_ _p_a_r_a_l_l_e_l___g_e_n_e_r_a_t_o_r_._i_p_y_n_b
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _P_y_t_h_o_n_ _s_o_u_r_c_e_ _c_o_d_e_:_ _p_a_r_a_l_l_e_l___g_e_n_e_r_a_t_o_r_._p_y
│ │ │ │ │ _G_a_l_l_e_r_y_ _g_e_n_e_r_a_t_e_d_ _b_y_ _S_p_h_i_n_x_-_G_a_l_l_e_r_y
│ │ │ │ │ _[_L_o_g_o_]
│ │ │ │ │ ******** NNaavviiggaattiioonn ********
│ │ │ │ │ User manual
│ │ │ │ │ * _W_h_y_ _j_o_b_l_i_b_:_ _p_r_o_j_e_c_t_ _g_o_a_l_s
│ │ │ ├── ./usr/share/doc/python-joblib-doc/html/auto_examples/parallel_memmap.html
│ │ │ │ @@ -80,30 +80,30 @@
│ │ │ │
│ │ │ │
│ │ │ │ -Elapsed time computing the average of couple of slices 1.14 s
│ │ │ │ +Elapsed time computing the average of couple of slices 1.17 s
│ │ │ │
│ │ │ │
│ │ │ │ joblib.Parallel is used to compute in parallel the average of all
│ │ │ │ slices using 2 workers.
│ │ │ │ from joblib import Parallel, delayed
│ │ │ │
│ │ │ │
│ │ │ │ tic = time.time()
│ │ │ │ results = Parallel(n_jobs=2)(delayed(slow_mean)(data, sl) for sl in slices)
│ │ │ │ toc = time.time()
│ │ │ │ print('\nElapsed time computing the average of couple of slices {:.2f} s'
│ │ │ │ .format(toc - tic))
│ │ │ │
│ │ │ │
│ │ │ │ -Elapsed time computing the average of couple of slices 0.79 s
│ │ │ │ +Elapsed time computing the average of couple of slices 0.91 s
│ │ │ │
│ │ │ │
│ │ │ │ Parallel processing is already faster than the sequential processing. It is
│ │ │ │ also possible to remove a bit of overhead by dumping the data array to a
│ │ │ │ memmap and pass the memmap to joblib.Parallel.
│ │ │ │ import os
│ │ │ │ from joblib import dump, load
│ │ │ │ @@ -121,15 +121,15 @@
│ │ │ │ tic = time.time()
│ │ │ │ results = Parallel(n_jobs=2)(delayed(slow_mean)(data, sl) for sl in slices)
│ │ │ │ toc = time.time()
│ │ │ │ print('\nElapsed time computing the average of couple of slices {:.2f} s\n'
│ │ │ │ .format(toc - tic))
│ │ │ │
│ │ │ │
│ │ │ │ -Elapsed time computing the average of couple of slices 0.61 s
│ │ │ │ +Elapsed time computing the average of couple of slices 0.63 s
│ │ │ │
│ │ │ │
│ │ │ │ Therefore, dumping large data array ahead of calling
│ │ │ │ joblib.Parallel can speed up the processing by removing some
│ │ │ │ overhead.
│ │ │ │
│ │ │ │
│ │ │ │ @@ -174,48 +174,48 @@
│ │ │ │
│ │ │ │
│ │ │ │ Expected means computed in the parent process:
│ │ │ │ - [0.49987477 0.50024927 0.50092615 0.50096471 0.50069688 0.5004066
│ │ │ │ - 0.50060994 0.50036408 0.50035265 0.50055318 0.50072066 0.5003558
│ │ │ │ - 0.50049655 0.50053941 0.50035478 0.50028029 0.49987738 0.49995818
│ │ │ │ - 0.49982899 0.4999466 0.50015474 0.50049419 0.50023403 0.50047833
│ │ │ │ - 0.50063408 0.50026159 0.50003125 0.49979556 0.49941395 0.49912523
│ │ │ │ - 0.49912842 0.49926774 0.49968439 0.50011544 0.49999139 0.50038923
│ │ │ │ - 0.50065458 0.50092796 0.5007343 0.5012061 0.50080119 0.50065387
│ │ │ │ - 0.49995719 0.4998642 0.49962744 0.499925 0.49959472 0.49985216
│ │ │ │ - 0.49994434 0.50001063 0.49982929 0.49990027 0.49988646 0.49971614
│ │ │ │ - 0.49966103 0.49965952 0.4998288 0.49998865 0.49985674 0.49982563
│ │ │ │ - 0.49993302 0.4997972 0.49994505 0.50036893 0.50000787 0.49980701
│ │ │ │ - 0.50012925 0.49995878 0.49971744 0.50018477 0.5003823 0.50047847
│ │ │ │ - 0.50073043 0.50068091 0.50080443 0.5010889 0.50133587 0.50129073
│ │ │ │ - 0.50153887 0.50129999 0.50115021 0.50049757 0.49995932 0.49960865
│ │ │ │ - 0.49942869 0.49901745 0.49940142 0.49982882 0.50017405 0.50019762
│ │ │ │ - 0.5006869 0.50038158 0.50003677 0.49977758 0.49976529]
│ │ │ │ + [0.49983744 0.49997927 0.49984857 0.49969885 0.49970667 0.50006498
│ │ │ │ + 0.50005839 0.50004322 0.50012483 0.49991468 0.49960626 0.49913659
│ │ │ │ + 0.49954083 0.4997693 0.49997494 0.49996148 0.50027288 0.50023874
│ │ │ │ + 0.50027415 0.5002561 0.50017541 0.49993566 0.49985783 0.49939561
│ │ │ │ + 0.49982308 0.49992475 0.50012113 0.49963753 0.49975728 0.49934186
│ │ │ │ + 0.49944284 0.49960008 0.50008999 0.50030957 0.50023869 0.50039096
│ │ │ │ + 0.50033152 0.50000375 0.5000804 0.50023468 0.49988861 0.49994346
│ │ │ │ + 0.5001036 0.50004809 0.499834 0.50003576 0.49983866 0.49967059
│ │ │ │ + 0.49973114 0.50012522 0.50011265 0.50007196 0.5002726 0.5003757
│ │ │ │ + 0.50011895 0.50020877 0.50069914 0.50060266 0.50066718 0.50057375
│ │ │ │ + 0.49996296 0.49944395 0.49953756 0.49920954 0.49932607 0.50002477
│ │ │ │ + 0.50070235 0.50049907 0.50058719 0.50063409 0.50017806 0.49983663
│ │ │ │ + 0.50026771 0.50046508 0.50058012 0.50091316 0.50055421 0.50023274
│ │ │ │ + 0.50029273 0.50005738 0.50008124 0.50048643 0.50048808 0.50014462
│ │ │ │ + 0.50021018 0.50013094 0.50015857 0.50041713 0.50048081 0.5000788
│ │ │ │ + 0.49990411 0.49983024 0.49966461 0.49978064 0.50020247]
│ │ │ │
│ │ │ │ Actual means computed by the worker processes:
│ │ │ │ - [0.49987477 0.50024927 0.50092615 0.50096471 0.50069688 0.5004066
│ │ │ │ - 0.50060994 0.50036408 0.50035265 0.50055318 0.50072066 0.5003558
│ │ │ │ - 0.50049655 0.50053941 0.50035478 0.50028029 0.49987738 0.49995818
│ │ │ │ - 0.49982899 0.4999466 0.50015474 0.50049419 0.50023403 0.50047833
│ │ │ │ - 0.50063408 0.50026159 0.50003125 0.49979556 0.49941395 0.49912523
│ │ │ │ - 0.49912842 0.49926774 0.49968439 0.50011544 0.49999139 0.50038923
│ │ │ │ - 0.50065458 0.50092796 0.5007343 0.5012061 0.50080119 0.50065387
│ │ │ │ - 0.49995719 0.4998642 0.49962744 0.499925 0.49959472 0.49985216
│ │ │ │ - 0.49994434 0.50001063 0.49982929 0.49990027 0.49988646 0.49971614
│ │ │ │ - 0.49966103 0.49965952 0.4998288 0.49998865 0.49985674 0.49982563
│ │ │ │ - 0.49993302 0.4997972 0.49994505 0.50036893 0.50000787 0.49980701
│ │ │ │ - 0.50012925 0.49995878 0.49971744 0.50018477 0.5003823 0.50047847
│ │ │ │ - 0.50073043 0.50068091 0.50080443 0.5010889 0.50133587 0.50129073
│ │ │ │ - 0.50153887 0.50129999 0.50115021 0.50049757 0.49995932 0.49960865
│ │ │ │ - 0.49942869 0.49901745 0.49940142 0.49982882 0.50017405 0.50019762
│ │ │ │ - 0.5006869 0.50038158 0.50003677 0.49977758 0.49976529]
│ │ │ │ + [0.49983744 0.49997927 0.49984857 0.49969885 0.49970667 0.50006498
│ │ │ │ + 0.50005839 0.50004322 0.50012483 0.49991468 0.49960626 0.49913659
│ │ │ │ + 0.49954083 0.4997693 0.49997494 0.49996148 0.50027288 0.50023874
│ │ │ │ + 0.50027415 0.5002561 0.50017541 0.49993566 0.49985783 0.49939561
│ │ │ │ + 0.49982308 0.49992475 0.50012113 0.49963753 0.49975728 0.49934186
│ │ │ │ + 0.49944284 0.49960008 0.50008999 0.50030957 0.50023869 0.50039096
│ │ │ │ + 0.50033152 0.50000375 0.5000804 0.50023468 0.49988861 0.49994346
│ │ │ │ + 0.5001036 0.50004809 0.499834 0.50003576 0.49983866 0.49967059
│ │ │ │ + 0.49973114 0.50012522 0.50011265 0.50007196 0.5002726 0.5003757
│ │ │ │ + 0.50011895 0.50020877 0.50069914 0.50060266 0.50066718 0.50057375
│ │ │ │ + 0.49996296 0.49944395 0.49953756 0.49920954 0.49932607 0.50002477
│ │ │ │ + 0.50070235 0.50049907 0.50058719 0.50063409 0.50017806 0.49983663
│ │ │ │ + 0.50026771 0.50046508 0.50058012 0.50091316 0.50055421 0.50023274
│ │ │ │ + 0.50029273 0.50005738 0.50008124 0.50048643 0.50048808 0.50014462
│ │ │ │ + 0.50021018 0.50013094 0.50015857 0.50041713 0.50048081 0.5000788
│ │ │ │ + 0.49990411 0.49983024 0.49966461 0.49978064 0.50020247]
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Clean-up the memmap¶
│ │ │ │
│ │ │ │ Remove the different memmap that we created. It might fail in Windows due
│ │ │ │ @@ -225,15 +225,15 @@
│ │ │ │
│ │ │ │ try:
│ │ │ │ shutil.rmtree(folder)
│ │ │ │ except: # noqa
│ │ │ │ print('Could not clean-up automatically.')
│ │ │ │
│ │ │ │
│ │ │ │ -Total running time of the script: (0 minutes 3.102 seconds)
│ │ │ │ +Total running time of the script: (0 minutes 3.574 seconds)
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -27,26 +27,26 @@
│ │ │ │ │ return _d_a_t_a[sl].mean()
│ │ │ │ │ First, we will evaluate the sequential computing on our problem.
│ │ │ │ │ _t_i_c = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ _r_e_s_u_l_t_s = [slow_mean(_d_a_t_a, sl) for sl in _s_l_i_c_e_s]
│ │ │ │ │ _t_o_c = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ print('\nElapsed time computing the average of couple of slices {:.2f} s'
│ │ │ │ │ .format(_t_o_c - _t_i_c))
│ │ │ │ │ -Elapsed time computing the average of couple of slices 1.14 s
│ │ │ │ │ +Elapsed time computing the average of couple of slices 1.17 s
│ │ │ │ │ _j_o_b_l_i_b_._P_a_r_a_l_l_e_l is used to compute in parallel the average of all slices using
│ │ │ │ │ 2 workers.
│ │ │ │ │ from joblib import _P_a_r_a_l_l_e_l, _d_e_l_a_y_e_d
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ _t_i_c = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ _r_e_s_u_l_t_s = _P_a_r_a_l_l_e_l(n_jobs=2)(_d_e_l_a_y_e_d(slow_mean)(_d_a_t_a, sl) for sl in _s_l_i_c_e_s)
│ │ │ │ │ _t_o_c = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ print('\nElapsed time computing the average of couple of slices {:.2f} s'
│ │ │ │ │ .format(_t_o_c - _t_i_c))
│ │ │ │ │ -Elapsed time computing the average of couple of slices 0.79 s
│ │ │ │ │ +Elapsed time computing the average of couple of slices 0.91 s
│ │ │ │ │ Parallel processing is already faster than the sequential processing. It is
│ │ │ │ │ also possible to remove a bit of overhead by dumping the data array to a memmap
│ │ │ │ │ and pass the memmap to _j_o_b_l_i_b_._P_a_r_a_l_l_e_l.
│ │ │ │ │ import os
│ │ │ │ │ from joblib import _d_u_m_p, _l_o_a_d
│ │ │ │ │
│ │ │ │ │ _f_o_l_d_e_r = './joblib_memmap'
│ │ │ │ │ @@ -60,15 +60,15 @@
│ │ │ │ │ _d_a_t_a = _l_o_a_d(_d_a_t_a___f_i_l_e_n_a_m_e___m_e_m_m_a_p, mmap_mode='r')
│ │ │ │ │
│ │ │ │ │ _t_i_c = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ _r_e_s_u_l_t_s = _P_a_r_a_l_l_e_l(n_jobs=2)(_d_e_l_a_y_e_d(slow_mean)(_d_a_t_a, sl) for sl in _s_l_i_c_e_s)
│ │ │ │ │ _t_o_c = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ print('\nElapsed time computing the average of couple of slices {:.2f} s\n'
│ │ │ │ │ .format(_t_o_c - _t_i_c))
│ │ │ │ │ -Elapsed time computing the average of couple of slices 0.61 s
│ │ │ │ │ +Elapsed time computing the average of couple of slices 0.63 s
│ │ │ │ │ Therefore, dumping large data array ahead of calling _j_o_b_l_i_b_._P_a_r_a_l_l_e_l can speed
│ │ │ │ │ up the processing by removing some overhead.
│ │ │ │ │ ********** WWrriittaabbllee mmeemmmmaapp ffoorr sshhaarreedd mmeemmoorryy _jj_oo_bb_ll_ii_bb_.._PP_aa_rr_aa_ll_ll_ee_ll_?¶ **********
│ │ │ │ │ slow_mean_write_output will compute the mean for some given slices as
│ │ │ │ │ in the previous example. However, the resulting mean will be directly
│ │ │ │ │ written on the output array.
│ │ │ │ │ def slow_mean_write_output(_d_a_t_a, sl, _o_u_t_p_u_t, idx):
│ │ │ │ │ @@ -99,58 +99,58 @@
│ │ │ │ │ None, None, None, None]
│ │ │ │ │ Compare the results from the output buffer with the expected results
│ │ │ │ │ print("\nExpected means computed in the parent process:\n {}"
│ │ │ │ │ .format(_n_p_._a_r_r_a_y(_r_e_s_u_l_t_s)))
│ │ │ │ │ print("\nActual means computed by the worker processes:\n {}"
│ │ │ │ │ .format(_o_u_t_p_u_t))
│ │ │ │ │ Expected means computed in the parent process:
│ │ │ │ │ - [0.49987477 0.50024927 0.50092615 0.50096471 0.50069688 0.5004066
│ │ │ │ │ - 0.50060994 0.50036408 0.50035265 0.50055318 0.50072066 0.5003558
│ │ │ │ │ - 0.50049655 0.50053941 0.50035478 0.50028029 0.49987738 0.49995818
│ │ │ │ │ - 0.49982899 0.4999466 0.50015474 0.50049419 0.50023403 0.50047833
│ │ │ │ │ - 0.50063408 0.50026159 0.50003125 0.49979556 0.49941395 0.49912523
│ │ │ │ │ - 0.49912842 0.49926774 0.49968439 0.50011544 0.49999139 0.50038923
│ │ │ │ │ - 0.50065458 0.50092796 0.5007343 0.5012061 0.50080119 0.50065387
│ │ │ │ │ - 0.49995719 0.4998642 0.49962744 0.499925 0.49959472 0.49985216
│ │ │ │ │ - 0.49994434 0.50001063 0.49982929 0.49990027 0.49988646 0.49971614
│ │ │ │ │ - 0.49966103 0.49965952 0.4998288 0.49998865 0.49985674 0.49982563
│ │ │ │ │ - 0.49993302 0.4997972 0.49994505 0.50036893 0.50000787 0.49980701
│ │ │ │ │ - 0.50012925 0.49995878 0.49971744 0.50018477 0.5003823 0.50047847
│ │ │ │ │ - 0.50073043 0.50068091 0.50080443 0.5010889 0.50133587 0.50129073
│ │ │ │ │ - 0.50153887 0.50129999 0.50115021 0.50049757 0.49995932 0.49960865
│ │ │ │ │ - 0.49942869 0.49901745 0.49940142 0.49982882 0.50017405 0.50019762
│ │ │ │ │ - 0.5006869 0.50038158 0.50003677 0.49977758 0.49976529]
│ │ │ │ │ + [0.49983744 0.49997927 0.49984857 0.49969885 0.49970667 0.50006498
│ │ │ │ │ + 0.50005839 0.50004322 0.50012483 0.49991468 0.49960626 0.49913659
│ │ │ │ │ + 0.49954083 0.4997693 0.49997494 0.49996148 0.50027288 0.50023874
│ │ │ │ │ + 0.50027415 0.5002561 0.50017541 0.49993566 0.49985783 0.49939561
│ │ │ │ │ + 0.49982308 0.49992475 0.50012113 0.49963753 0.49975728 0.49934186
│ │ │ │ │ + 0.49944284 0.49960008 0.50008999 0.50030957 0.50023869 0.50039096
│ │ │ │ │ + 0.50033152 0.50000375 0.5000804 0.50023468 0.49988861 0.49994346
│ │ │ │ │ + 0.5001036 0.50004809 0.499834 0.50003576 0.49983866 0.49967059
│ │ │ │ │ + 0.49973114 0.50012522 0.50011265 0.50007196 0.5002726 0.5003757
│ │ │ │ │ + 0.50011895 0.50020877 0.50069914 0.50060266 0.50066718 0.50057375
│ │ │ │ │ + 0.49996296 0.49944395 0.49953756 0.49920954 0.49932607 0.50002477
│ │ │ │ │ + 0.50070235 0.50049907 0.50058719 0.50063409 0.50017806 0.49983663
│ │ │ │ │ + 0.50026771 0.50046508 0.50058012 0.50091316 0.50055421 0.50023274
│ │ │ │ │ + 0.50029273 0.50005738 0.50008124 0.50048643 0.50048808 0.50014462
│ │ │ │ │ + 0.50021018 0.50013094 0.50015857 0.50041713 0.50048081 0.5000788
│ │ │ │ │ + 0.49990411 0.49983024 0.49966461 0.49978064 0.50020247]
│ │ │ │ │
│ │ │ │ │ Actual means computed by the worker processes:
│ │ │ │ │ - [0.49987477 0.50024927 0.50092615 0.50096471 0.50069688 0.5004066
│ │ │ │ │ - 0.50060994 0.50036408 0.50035265 0.50055318 0.50072066 0.5003558
│ │ │ │ │ - 0.50049655 0.50053941 0.50035478 0.50028029 0.49987738 0.49995818
│ │ │ │ │ - 0.49982899 0.4999466 0.50015474 0.50049419 0.50023403 0.50047833
│ │ │ │ │ - 0.50063408 0.50026159 0.50003125 0.49979556 0.49941395 0.49912523
│ │ │ │ │ - 0.49912842 0.49926774 0.49968439 0.50011544 0.49999139 0.50038923
│ │ │ │ │ - 0.50065458 0.50092796 0.5007343 0.5012061 0.50080119 0.50065387
│ │ │ │ │ - 0.49995719 0.4998642 0.49962744 0.499925 0.49959472 0.49985216
│ │ │ │ │ - 0.49994434 0.50001063 0.49982929 0.49990027 0.49988646 0.49971614
│ │ │ │ │ - 0.49966103 0.49965952 0.4998288 0.49998865 0.49985674 0.49982563
│ │ │ │ │ - 0.49993302 0.4997972 0.49994505 0.50036893 0.50000787 0.49980701
│ │ │ │ │ - 0.50012925 0.49995878 0.49971744 0.50018477 0.5003823 0.50047847
│ │ │ │ │ - 0.50073043 0.50068091 0.50080443 0.5010889 0.50133587 0.50129073
│ │ │ │ │ - 0.50153887 0.50129999 0.50115021 0.50049757 0.49995932 0.49960865
│ │ │ │ │ - 0.49942869 0.49901745 0.49940142 0.49982882 0.50017405 0.50019762
│ │ │ │ │ - 0.5006869 0.50038158 0.50003677 0.49977758 0.49976529]
│ │ │ │ │ + [0.49983744 0.49997927 0.49984857 0.49969885 0.49970667 0.50006498
│ │ │ │ │ + 0.50005839 0.50004322 0.50012483 0.49991468 0.49960626 0.49913659
│ │ │ │ │ + 0.49954083 0.4997693 0.49997494 0.49996148 0.50027288 0.50023874
│ │ │ │ │ + 0.50027415 0.5002561 0.50017541 0.49993566 0.49985783 0.49939561
│ │ │ │ │ + 0.49982308 0.49992475 0.50012113 0.49963753 0.49975728 0.49934186
│ │ │ │ │ + 0.49944284 0.49960008 0.50008999 0.50030957 0.50023869 0.50039096
│ │ │ │ │ + 0.50033152 0.50000375 0.5000804 0.50023468 0.49988861 0.49994346
│ │ │ │ │ + 0.5001036 0.50004809 0.499834 0.50003576 0.49983866 0.49967059
│ │ │ │ │ + 0.49973114 0.50012522 0.50011265 0.50007196 0.5002726 0.5003757
│ │ │ │ │ + 0.50011895 0.50020877 0.50069914 0.50060266 0.50066718 0.50057375
│ │ │ │ │ + 0.49996296 0.49944395 0.49953756 0.49920954 0.49932607 0.50002477
│ │ │ │ │ + 0.50070235 0.50049907 0.50058719 0.50063409 0.50017806 0.49983663
│ │ │ │ │ + 0.50026771 0.50046508 0.50058012 0.50091316 0.50055421 0.50023274
│ │ │ │ │ + 0.50029273 0.50005738 0.50008124 0.50048643 0.50048808 0.50014462
│ │ │ │ │ + 0.50021018 0.50013094 0.50015857 0.50041713 0.50048081 0.5000788
│ │ │ │ │ + 0.49990411 0.49983024 0.49966461 0.49978064 0.50020247]
│ │ │ │ │ ********** CClleeaann--uupp tthhee mmeemmmmaapp_?¶ **********
│ │ │ │ │ Remove the different memmap that we created. It might fail in Windows
│ │ │ │ │ due to file permissions.
│ │ │ │ │ import shutil
│ │ │ │ │
│ │ │ │ │ try:
│ │ │ │ │ _s_h_u_t_i_l_._r_m_t_r_e_e(_f_o_l_d_e_r)
│ │ │ │ │ except: # noqa
│ │ │ │ │ print('Could not clean-up automatically.')
│ │ │ │ │ -TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 3.102 seconds)
│ │ │ │ │ +TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 3.574 seconds)
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _J_u_p_y_t_e_r_ _n_o_t_e_b_o_o_k_:_ _p_a_r_a_l_l_e_l___m_e_m_m_a_p_._i_p_y_n_b
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _P_y_t_h_o_n_ _s_o_u_r_c_e_ _c_o_d_e_:_ _p_a_r_a_l_l_e_l___m_e_m_m_a_p_._p_y
│ │ │ │ │ _G_a_l_l_e_r_y_ _g_e_n_e_r_a_t_e_d_ _b_y_ _S_p_h_i_n_x_-_G_a_l_l_e_r_y
│ │ │ │ │ _[_L_o_g_o_]
│ │ │ │ │ ******** NNaavviiggaattiioonn ********
│ │ │ │ │ User manual
│ │ │ │ │ * _W_h_y_ _j_o_b_l_i_b_:_ _p_r_o_j_e_c_t_ _g_o_a_l_s
│ │ │ ├── ./usr/share/doc/python-joblib-doc/html/auto_examples/parallel_random_state.html
│ │ │ │ @@ -77,19 +77,19 @@
│ │ │ │ n_vectors = 5
│ │ │ │ random_vector = [stochastic_function(10) for _ in range(n_vectors)]
│ │ │ │ print('\nThe different generated vectors in a sequential manner are:\n {}'
│ │ │ │ .format(np.array(random_vector)))
│ │ │ │
│ │ │ │
│ │ │ │ The different generated vectors in a sequential manner are:
│ │ │ │ - [[8 2 9 5 3]
│ │ │ │ - [3 7 8 0 1]
│ │ │ │ - [7 9 7 0 6]
│ │ │ │ - [8 9 3 9 2]
│ │ │ │ - [0 4 0 1 0]]
│ │ │ │ + [[7 4 3 5 6]
│ │ │ │ + [9 9 9 1 9]
│ │ │ │ + [3 5 2 7 1]
│ │ │ │ + [4 8 4 3 4]
│ │ │ │ + [6 4 5 9 4]]
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Parallel behavior¶
│ │ │ │
│ │ │ │ Joblib provides three different backends: loky (default), threading, and
│ │ │ │ @@ -98,33 +98,33 @@
│ │ │ │
backend = 'loky'
│ │ │ │ random_vector = Parallel(n_jobs=2, backend=backend)(delayed(
│ │ │ │ stochastic_function)(10) for _ in range(n_vectors))
│ │ │ │ print_vector(random_vector, backend)
│ │ │ │
│ │ │ │
│ │ │ │ The different generated vectors using the loky backend are:
│ │ │ │ - [[8 5 8 7 0]
│ │ │ │ - [4 6 1 0 6]
│ │ │ │ - [9 7 1 2 9]
│ │ │ │ - [5 4 5 6 8]
│ │ │ │ - [2 6 3 7 8]]
│ │ │ │ + [[3 2 2 9 1]
│ │ │ │ + [8 1 1 0 6]
│ │ │ │ + [6 5 1 7 2]
│ │ │ │ + [7 0 0 3 4]
│ │ │ │ + [3 3 4 9 9]]
│ │ │ │
│ │ │ │
│ │ │ │ backend = 'threading'
│ │ │ │ random_vector = Parallel(n_jobs=2, backend=backend)(delayed(
│ │ │ │ stochastic_function)(10) for _ in range(n_vectors))
│ │ │ │ print_vector(random_vector, backend)
│ │ │ │
│ │ │ │
│ │ │ │ The different generated vectors using the threading backend are:
│ │ │ │ - [[6 2 6 2 2]
│ │ │ │ - [3 0 6 6 2]
│ │ │ │ - [1 3 7 8 1]
│ │ │ │ - [5 9 4 1 3]
│ │ │ │ - [6 4 2 6 3]]
│ │ │ │ + [[0 8 0 4 9]
│ │ │ │ + [9 9 8 8 7]
│ │ │ │ + [9 3 0 2 3]
│ │ │ │ + [2 7 5 8 7]
│ │ │ │ + [8 1 3 8 8]]
│ │ │ │
│ │ │ │
│ │ │ │ Loky and the threading backends behave exactly as in the sequential case and
│ │ │ │ do not require more care. However, this is not the case regarding the
│ │ │ │ multiprocessing backend with the “fork” or “forkserver” start method because
│ │ │ │ the state of the global numpy random stated will be exactly duplicated
│ │ │ │ in all the workers
│ │ │ │ @@ -137,19 +137,19 @@
│ │ │ │ backend = 'multiprocessing'
│ │ │ │ random_vector = Parallel(n_jobs=2, backend=backend)(delayed(
│ │ │ │ stochastic_function)(10) for _ in range(n_vectors))
│ │ │ │ print_vector(random_vector, backend)
│ │ │ │
│ │ │ │
│ │ │ │ The different generated vectors using the multiprocessing backend are:
│ │ │ │ - [[8 1 9 5 0]
│ │ │ │ - [7 3 6 1 1]
│ │ │ │ - [8 2 8 2 1]
│ │ │ │ - [7 4 6 7 7]
│ │ │ │ - [7 5 0 7 3]]
│ │ │ │ + [[0 0 4 7 2]
│ │ │ │ + [7 8 8 5 2]
│ │ │ │ + [2 8 4 5 0]
│ │ │ │ + [3 0 9 1 5]
│ │ │ │ + [5 3 6 1 9]]
│ │ │ │
│ │ │ │
│ │ │ │ Some of the generated vectors are exactly the same, which can be a
│ │ │ │ problem for the application.
│ │ │ │ Technically, the reason is that all forked Python processes share the
│ │ │ │ same exact random seed. As a result, we obtain twice the same randomly
│ │ │ │ generated vectors because we are using n_jobs=2. A solution is to
│ │ │ │ @@ -166,19 +166,19 @@
│ │ │ │
if mp.get_start_method() != "spawn":
│ │ │ │ random_vector = Parallel(n_jobs=2, backend=backend)(delayed(
│ │ │ │ stochastic_function_seeded)(10, None) for _ in range(n_vectors))
│ │ │ │ print_vector(random_vector, backend)
│ │ │ │
│ │ │ │
│ │ │ │ The different generated vectors using the multiprocessing backend are:
│ │ │ │ - [[6 8 4 4 0]
│ │ │ │ - [7 8 4 8 3]
│ │ │ │ - [2 8 7 8 5]
│ │ │ │ - [7 6 5 9 2]
│ │ │ │ - [8 5 1 9 4]]
│ │ │ │ + [[8 7 3 3 5]
│ │ │ │ + [4 5 9 1 5]
│ │ │ │ + [7 8 1 2 8]
│ │ │ │ + [6 1 1 1 5]
│ │ │ │ + [7 5 9 3 0]]
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Fixing the random state to obtain deterministic results¶
│ │ │ │
│ │ │ │ The pattern of stochastic_function_seeded has another advantage: it
│ │ │ │ @@ -195,29 +195,29 @@
│ │ │ │
│ │ │ │ random_vector = Parallel(n_jobs=2, backend=backend)(delayed(
│ │ │ │ stochastic_function_seeded)(10, rng) for rng in random_state)
│ │ │ │ print_vector(random_vector, backend)
│ │ │ │
│ │ │ │
│ │ │ │ The different generated vectors using the multiprocessing backend are:
│ │ │ │ - [[7 2 3 7 6]
│ │ │ │ - [1 5 9 5 1]
│ │ │ │ - [9 7 4 7 1]
│ │ │ │ - [6 9 2 9 8]
│ │ │ │ - [5 9 5 3 6]]
│ │ │ │ + [[2 0 8 0 3]
│ │ │ │ + [8 3 6 8 7]
│ │ │ │ + [6 7 9 9 1]
│ │ │ │ + [5 7 3 2 3]
│ │ │ │ + [7 6 6 5 4]]
│ │ │ │
│ │ │ │ The different generated vectors using the multiprocessing backend are:
│ │ │ │ - [[7 2 3 7 6]
│ │ │ │ - [1 5 9 5 1]
│ │ │ │ - [9 7 4 7 1]
│ │ │ │ - [6 9 2 9 8]
│ │ │ │ - [5 9 5 3 6]]
│ │ │ │ + [[2 0 8 0 3]
│ │ │ │ + [8 3 6 8 7]
│ │ │ │ + [6 7 9 9 1]
│ │ │ │ + [5 7 3 2 3]
│ │ │ │ + [7 6 6 5 4]]
│ │ │ │
│ │ │ │
│ │ │ │ -Total running time of the script: (0 minutes 1.223 seconds)
│ │ │ │ +Total running time of the script: (0 minutes 1.519 seconds)
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -25,42 +25,42 @@
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ _n___v_e_c_t_o_r_s = 5
│ │ │ │ │ _r_a_n_d_o_m___v_e_c_t_o_r = [stochastic_function(10) for _ in range(_n___v_e_c_t_o_r_s)]
│ │ │ │ │ print('\nThe different generated vectors in a sequential manner are:\n {}'
│ │ │ │ │ .format(_n_p_._a_r_r_a_y(_r_a_n_d_o_m___v_e_c_t_o_r)))
│ │ │ │ │ The different generated vectors in a sequential manner are:
│ │ │ │ │ - [[8 2 9 5 3]
│ │ │ │ │ - [3 7 8 0 1]
│ │ │ │ │ - [7 9 7 0 6]
│ │ │ │ │ - [8 9 3 9 2]
│ │ │ │ │ - [0 4 0 1 0]]
│ │ │ │ │ + [[7 4 3 5 6]
│ │ │ │ │ + [9 9 9 1 9]
│ │ │ │ │ + [3 5 2 7 1]
│ │ │ │ │ + [4 8 4 3 4]
│ │ │ │ │ + [6 4 5 9 4]]
│ │ │ │ │ ********** PPaarraalllleell bbeehhaavviioorr_?¶ **********
│ │ │ │ │ Joblib provides three different backends: loky (default), threading,
│ │ │ │ │ and multiprocessing.
│ │ │ │ │ _b_a_c_k_e_n_d = 'loky'
│ │ │ │ │ _r_a_n_d_o_m___v_e_c_t_o_r = _P_a_r_a_l_l_e_l(n_jobs=2, _b_a_c_k_e_n_d=_b_a_c_k_e_n_d)(_d_e_l_a_y_e_d(
│ │ │ │ │ stochastic_function)(10) for _ in range(_n___v_e_c_t_o_r_s))
│ │ │ │ │ print_vector(_r_a_n_d_o_m___v_e_c_t_o_r, _b_a_c_k_e_n_d)
│ │ │ │ │ The different generated vectors using the loky backend are:
│ │ │ │ │ - [[8 5 8 7 0]
│ │ │ │ │ - [4 6 1 0 6]
│ │ │ │ │ - [9 7 1 2 9]
│ │ │ │ │ - [5 4 5 6 8]
│ │ │ │ │ - [2 6 3 7 8]]
│ │ │ │ │ + [[3 2 2 9 1]
│ │ │ │ │ + [8 1 1 0 6]
│ │ │ │ │ + [6 5 1 7 2]
│ │ │ │ │ + [7 0 0 3 4]
│ │ │ │ │ + [3 3 4 9 9]]
│ │ │ │ │ _b_a_c_k_e_n_d = 'threading'
│ │ │ │ │ _r_a_n_d_o_m___v_e_c_t_o_r = _P_a_r_a_l_l_e_l(n_jobs=2, _b_a_c_k_e_n_d=_b_a_c_k_e_n_d)(_d_e_l_a_y_e_d(
│ │ │ │ │ stochastic_function)(10) for _ in range(_n___v_e_c_t_o_r_s))
│ │ │ │ │ print_vector(_r_a_n_d_o_m___v_e_c_t_o_r, _b_a_c_k_e_n_d)
│ │ │ │ │ The different generated vectors using the threading backend are:
│ │ │ │ │ - [[6 2 6 2 2]
│ │ │ │ │ - [3 0 6 6 2]
│ │ │ │ │ - [1 3 7 8 1]
│ │ │ │ │ - [5 9 4 1 3]
│ │ │ │ │ - [6 4 2 6 3]]
│ │ │ │ │ + [[0 8 0 4 9]
│ │ │ │ │ + [9 9 8 8 7]
│ │ │ │ │ + [9 3 0 2 3]
│ │ │ │ │ + [2 7 5 8 7]
│ │ │ │ │ + [8 1 3 8 8]]
│ │ │ │ │ Loky and the threading backends behave exactly as in the sequential case and do
│ │ │ │ │ not require more care. However, this is not the case regarding the
│ │ │ │ │ multiprocessing backend with the “fork” or “forkserver” start method because
│ │ │ │ │ the state of the global numpy random stated will be exactly duplicated in all
│ │ │ │ │ the workers
│ │ │ │ │ Note: on platforms for which the default start method is “spawn”, we do not
│ │ │ │ │ have this problem but we cannot use this in a Python script without using the
│ │ │ │ │ @@ -69,19 +69,19 @@
│ │ │ │ │ import multiprocessing as mp
│ │ │ │ │ if _m_p_._g_e_t___s_t_a_r_t___m_e_t_h_o_d() != "spawn":
│ │ │ │ │ _b_a_c_k_e_n_d = 'multiprocessing'
│ │ │ │ │ _r_a_n_d_o_m___v_e_c_t_o_r = _P_a_r_a_l_l_e_l(n_jobs=2, _b_a_c_k_e_n_d=_b_a_c_k_e_n_d)(_d_e_l_a_y_e_d(
│ │ │ │ │ stochastic_function)(10) for _ in range(_n___v_e_c_t_o_r_s))
│ │ │ │ │ print_vector(_r_a_n_d_o_m___v_e_c_t_o_r, _b_a_c_k_e_n_d)
│ │ │ │ │ The different generated vectors using the multiprocessing backend are:
│ │ │ │ │ - [[8 1 9 5 0]
│ │ │ │ │ - [7 3 6 1 1]
│ │ │ │ │ - [8 2 8 2 1]
│ │ │ │ │ - [7 4 6 7 7]
│ │ │ │ │ - [7 5 0 7 3]]
│ │ │ │ │ + [[0 0 4 7 2]
│ │ │ │ │ + [7 8 8 5 2]
│ │ │ │ │ + [2 8 4 5 0]
│ │ │ │ │ + [3 0 9 1 5]
│ │ │ │ │ + [5 3 6 1 9]]
│ │ │ │ │ Some of the generated vectors are exactly the same, which can be a problem for
│ │ │ │ │ the application.
│ │ │ │ │ Technically, the reason is that all forked Python processes share the same
│ │ │ │ │ exact random seed. As a result, we obtain twice the same randomly generated
│ │ │ │ │ vectors because we are using n_jobs=2. A solution is to set the random state
│ │ │ │ │ within the function which is passed to _j_o_b_l_i_b_._P_a_r_a_l_l_e_l.
│ │ │ │ │ def stochastic_function_seeded(max_value, _r_a_n_d_o_m___s_t_a_t_e):
│ │ │ │ │ @@ -91,19 +91,19 @@
│ │ │ │ │ seed by passing None at every function call. In this case, we see that the
│ │ │ │ │ generated vectors are all different.
│ │ │ │ │ if _m_p_._g_e_t___s_t_a_r_t___m_e_t_h_o_d() != "spawn":
│ │ │ │ │ _r_a_n_d_o_m___v_e_c_t_o_r = _P_a_r_a_l_l_e_l(n_jobs=2, _b_a_c_k_e_n_d=_b_a_c_k_e_n_d)(_d_e_l_a_y_e_d(
│ │ │ │ │ stochastic_function_seeded)(10, None) for _ in range(_n___v_e_c_t_o_r_s))
│ │ │ │ │ print_vector(_r_a_n_d_o_m___v_e_c_t_o_r, _b_a_c_k_e_n_d)
│ │ │ │ │ The different generated vectors using the multiprocessing backend are:
│ │ │ │ │ - [[6 8 4 4 0]
│ │ │ │ │ - [7 8 4 8 3]
│ │ │ │ │ - [2 8 7 8 5]
│ │ │ │ │ - [7 6 5 9 2]
│ │ │ │ │ - [8 5 1 9 4]]
│ │ │ │ │ + [[8 7 3 3 5]
│ │ │ │ │ + [4 5 9 1 5]
│ │ │ │ │ + [7 8 1 2 8]
│ │ │ │ │ + [6 1 1 1 5]
│ │ │ │ │ + [7 5 9 3 0]]
│ │ │ │ │ ********** FFiixxiinngg tthhee rraannddoomm ssttaattee ttoo oobbttaaiinn ddeetteerrmmiinniissttiicc rreessuullttss_?¶ **********
│ │ │ │ │ The pattern of stochastic_function_seeded has another advantage: it
│ │ │ │ │ allows to control the random_state by passing a known seed. So for
│ │ │ │ │ instance, we can replicate the same generation of vectors by passing
│ │ │ │ │ a fixed state as follows.
│ │ │ │ │ if _m_p_._g_e_t___s_t_a_r_t___m_e_t_h_o_d() != "spawn":
│ │ │ │ │ _r_a_n_d_o_m___s_t_a_t_e = _n_p_._r_a_n_d_o_m_._r_a_n_d_i_n_t(_n_p_._i_i_n_f_o(_n_p_._i_n_t_3_2).max, size=_n___v_e_c_t_o_r_s)
│ │ │ │ │ @@ -112,27 +112,27 @@
│ │ │ │ │ stochastic_function_seeded)(10, rng) for rng in _r_a_n_d_o_m___s_t_a_t_e)
│ │ │ │ │ print_vector(_r_a_n_d_o_m___v_e_c_t_o_r, _b_a_c_k_e_n_d)
│ │ │ │ │
│ │ │ │ │ _r_a_n_d_o_m___v_e_c_t_o_r = _P_a_r_a_l_l_e_l(n_jobs=2, _b_a_c_k_e_n_d=_b_a_c_k_e_n_d)(_d_e_l_a_y_e_d(
│ │ │ │ │ stochastic_function_seeded)(10, rng) for rng in _r_a_n_d_o_m___s_t_a_t_e)
│ │ │ │ │ print_vector(_r_a_n_d_o_m___v_e_c_t_o_r, _b_a_c_k_e_n_d)
│ │ │ │ │ The different generated vectors using the multiprocessing backend are:
│ │ │ │ │ - [[7 2 3 7 6]
│ │ │ │ │ - [1 5 9 5 1]
│ │ │ │ │ - [9 7 4 7 1]
│ │ │ │ │ - [6 9 2 9 8]
│ │ │ │ │ - [5 9 5 3 6]]
│ │ │ │ │ + [[2 0 8 0 3]
│ │ │ │ │ + [8 3 6 8 7]
│ │ │ │ │ + [6 7 9 9 1]
│ │ │ │ │ + [5 7 3 2 3]
│ │ │ │ │ + [7 6 6 5 4]]
│ │ │ │ │
│ │ │ │ │ The different generated vectors using the multiprocessing backend are:
│ │ │ │ │ - [[7 2 3 7 6]
│ │ │ │ │ - [1 5 9 5 1]
│ │ │ │ │ - [9 7 4 7 1]
│ │ │ │ │ - [6 9 2 9 8]
│ │ │ │ │ - [5 9 5 3 6]]
│ │ │ │ │ -TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 1.223 seconds)
│ │ │ │ │ + [[2 0 8 0 3]
│ │ │ │ │ + [8 3 6 8 7]
│ │ │ │ │ + [6 7 9 9 1]
│ │ │ │ │ + [5 7 3 2 3]
│ │ │ │ │ + [7 6 6 5 4]]
│ │ │ │ │ +TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 1.519 seconds)
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _J_u_p_y_t_e_r_ _n_o_t_e_b_o_o_k_:_ _p_a_r_a_l_l_e_l___r_a_n_d_o_m___s_t_a_t_e_._i_p_y_n_b
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _P_y_t_h_o_n_ _s_o_u_r_c_e_ _c_o_d_e_:_ _p_a_r_a_l_l_e_l___r_a_n_d_o_m___s_t_a_t_e_._p_y
│ │ │ │ │ _G_a_l_l_e_r_y_ _g_e_n_e_r_a_t_e_d_ _b_y_ _S_p_h_i_n_x_-_G_a_l_l_e_r_y
│ │ │ │ │ _[_L_o_g_o_]
│ │ │ │ │ ******** NNaavviiggaattiioonn ********
│ │ │ │ │ User manual
│ │ │ │ │ * _W_h_y_ _j_o_b_l_i_b_:_ _p_r_o_j_e_c_t_ _g_o_a_l_s
│ │ │ ├── ./usr/share/doc/python-joblib-doc/html/auto_examples/serialization_and_wrappers.html
│ │ │ │ @@ -86,15 +86,15 @@
│ │ │ │
│ │ │ │ t_start = time.time()
│ │ │ │ Parallel(n_jobs=2)(delayed(func_async)(21, large_list) for _ in range(1))
│ │ │ │ print("With loky backend and cloudpickle serialization: {:.3f}s"
│ │ │ │ .format(time.time() - t_start))
│ │ │ │
│ │ │ │
│ │ │ │ -With loky backend and cloudpickle serialization: 0.081s
│ │ │ │ +With loky backend and cloudpickle serialization: 0.225s
│ │ │ │
│ │ │ │
│ │ │ │ If you are on a UNIX system, it is possible to fallback to the old
│ │ │ │ multiprocessing backend, which can pickle interactively defined functions
│ │ │ │ with the default pickle module, which is faster for such large objects.
│ │ │ │ import multiprocessing as mp
│ │ │ │ if mp.get_start_method() != "spawn":
│ │ │ │ @@ -105,15 +105,15 @@
│ │ │ │ t_start = time.time()
│ │ │ │ Parallel(n_jobs=2)(
│ │ │ │ delayed(func_async)(21, large_list) for _ in range(1))
│ │ │ │ print("With multiprocessing backend and pickle serialization: {:.3f}s"
│ │ │ │ .format(time.time() - t_start))
│ │ │ │
│ │ │ │
│ │ │ │ -With multiprocessing backend and pickle serialization: 0.271s
│ │ │ │ +With multiprocessing backend and pickle serialization: 0.696s
│ │ │ │
│ │ │ │
│ │ │ │ However, using fork to start new processes can cause violation of the
│ │ │ │ POSIX specification and can have bad interaction with compiled extensions
│ │ │ │ that use openmp. Also, it is not possible to start processes with
│ │ │ │ fork on windows where only spawn is available. The loky backend
│ │ │ │ has been developed to mitigate these issues.
│ │ │ │ @@ -130,15 +130,15 @@
│ │ │ │
│ │ │ │ set_loky_pickler('pickle')
│ │ │ │ t_start = time.time()
│ │ │ │ Parallel(n_jobs=2)(delayed(id)(large_list) for _ in range(1))
│ │ │ │ print("With pickle serialization: {:.3f}s".format(time.time() - t_start))
│ │ │ │
│ │ │ │
│ │ │ │ -With pickle serialization: 0.125s
│ │ │ │ +With pickle serialization: 0.198s
│ │ │ │
│ │ │ │
│ │ │ │ However, the function and objects defined in __main__ are not
│ │ │ │ serializable anymore using pickle and it is not possible to call
│ │ │ │ func_async using this pickler.
│ │ │ │ def func_async(i, *args):
│ │ │ │ return 2 * i
│ │ │ │ @@ -201,28 +201,28 @@
│ │ │ │
│ │ │ │ t_start = time.time()
│ │ │ │ Parallel(n_jobs=2)(func_async_wrapped(21, large_list) for _ in range(1))
│ │ │ │ print("With pickle from stdlib and wrapper: {:.3f}s"
│ │ │ │ .format(time.time() - t_start))
│ │ │ │
│ │ │ │
│ │ │ │ -With pickle from stdlib and wrapper: 0.354s
│ │ │ │ +With pickle from stdlib and wrapper: 0.873s
│ │ │ │
│ │ │ │
│ │ │ │ The same wrapper can also be used for non-picklable classes. Note that the
│ │ │ │ side effects of wrap_non_picklable_objects on objects can break magic
│ │ │ │ methods such as __add__ and can mess up the isinstance and
│ │ │ │ issubclass functions. Some improvements will be considered if use-cases
│ │ │ │ are reported.
│ │ │ │ # Reset the loky_pickler to avoid border effects with other examples in
│ │ │ │ # sphinx-gallery.
│ │ │ │ set_loky_pickler()
│ │ │ │
│ │ │ │
│ │ │ │ -Total running time of the script: (0 minutes 1.004 seconds)
│ │ │ │ +Total running time of the script: (0 minutes 2.225 seconds)
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -35,30 +35,30 @@
│ │ │ │ │ # object).
│ │ │ │ │ _l_a_r_g_e___l_i_s_t = list(range(1000000))
│ │ │ │ │
│ │ │ │ │ _t___s_t_a_r_t = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ _P_a_r_a_l_l_e_l(n_jobs=2)(_d_e_l_a_y_e_d(func_async)(21, _l_a_r_g_e___l_i_s_t) for _ in range(1))
│ │ │ │ │ print("With loky backend and cloudpickle serialization: {:.3f}s"
│ │ │ │ │ .format(_t_i_m_e_._t_i_m_e() - _t___s_t_a_r_t))
│ │ │ │ │ -With loky backend and cloudpickle serialization: 0.081s
│ │ │ │ │ +With loky backend and cloudpickle serialization: 0.225s
│ │ │ │ │ If you are on a UNIX system, it is possible to fallback to the old
│ │ │ │ │ multiprocessing backend, which can pickle interactively defined functions with
│ │ │ │ │ the default pickle module, which is faster for such large objects.
│ │ │ │ │ import multiprocessing as mp
│ │ │ │ │ if _m_p_._g_e_t___s_t_a_r_t___m_e_t_h_o_d() != "spawn":
│ │ │ │ │ def func_async(i, *args):
│ │ │ │ │ return 2 * i
│ │ │ │ │
│ │ │ │ │ with _p_a_r_a_l_l_e_l___c_o_n_f_i_g('multiprocessing'):
│ │ │ │ │ _t___s_t_a_r_t = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ _P_a_r_a_l_l_e_l(n_jobs=2)(
│ │ │ │ │ _d_e_l_a_y_e_d(func_async)(21, _l_a_r_g_e___l_i_s_t) for _ in range(1))
│ │ │ │ │ print("With multiprocessing backend and pickle serialization: {:.3f}s"
│ │ │ │ │ .format(_t_i_m_e_._t_i_m_e() - _t___s_t_a_r_t))
│ │ │ │ │ -With multiprocessing backend and pickle serialization: 0.271s
│ │ │ │ │ +With multiprocessing backend and pickle serialization: 0.696s
│ │ │ │ │ However, using fork to start new processes can cause violation of the POSIX
│ │ │ │ │ specification and can have bad interaction with compiled extensions that use
│ │ │ │ │ openmp. Also, it is not possible to start processes with fork on windows where
│ │ │ │ │ only spawn is available. The loky backend has been developed to mitigate these
│ │ │ │ │ issues.
│ │ │ │ │ To have fast pickling with loky, it is possible to rely on pickle to serialize
│ │ │ │ │ all communications between the main process and the workers with the loky
│ │ │ │ │ @@ -71,15 +71,15 @@
│ │ │ │ │ # we do not pass the desired function ``func_async`` as it is not picklable
│ │ │ │ │ # but it is replaced by ``id`` for demonstration purposes.
│ │ │ │ │
│ │ │ │ │ set_loky_pickler('pickle')
│ │ │ │ │ _t___s_t_a_r_t = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ _P_a_r_a_l_l_e_l(n_jobs=2)(_d_e_l_a_y_e_d(id)(_l_a_r_g_e___l_i_s_t) for _ in range(1))
│ │ │ │ │ print("With pickle serialization: {:.3f}s".format(_t_i_m_e_._t_i_m_e() - _t___s_t_a_r_t))
│ │ │ │ │ -With pickle serialization: 0.125s
│ │ │ │ │ +With pickle serialization: 0.198s
│ │ │ │ │ However, the function and objects defined in __main__ are not serializable
│ │ │ │ │ anymore using pickle and it is not possible to call func_async using this
│ │ │ │ │ pickler.
│ │ │ │ │ def func_async(i, *args):
│ │ │ │ │ return 2 * i
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ @@ -146,23 +146,23 @@
│ │ │ │ │ return 2 * i
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ _t___s_t_a_r_t = _t_i_m_e_._t_i_m_e()
│ │ │ │ │ _P_a_r_a_l_l_e_l(n_jobs=2)(func_async_wrapped(21, _l_a_r_g_e___l_i_s_t) for _ in range(1))
│ │ │ │ │ print("With pickle from stdlib and wrapper: {:.3f}s"
│ │ │ │ │ .format(_t_i_m_e_._t_i_m_e() - _t___s_t_a_r_t))
│ │ │ │ │ -With pickle from stdlib and wrapper: 0.354s
│ │ │ │ │ +With pickle from stdlib and wrapper: 0.873s
│ │ │ │ │ The same wrapper can also be used for non-picklable classes. Note that the side
│ │ │ │ │ effects of wrap_non_picklable_objects on objects can break magic methods such
│ │ │ │ │ as __add__ and can mess up the isinstance and issubclass functions. Some
│ │ │ │ │ improvements will be considered if use-cases are reported.
│ │ │ │ │ # Reset the loky_pickler to avoid border effects with other examples in
│ │ │ │ │ # sphinx-gallery.
│ │ │ │ │ set_loky_pickler()
│ │ │ │ │ -TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 1.004 seconds)
│ │ │ │ │ +TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 2.225 seconds)
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _J_u_p_y_t_e_r_ _n_o_t_e_b_o_o_k_:_ _s_e_r_i_a_l_i_z_a_t_i_o_n___a_n_d___w_r_a_p_p_e_r_s_._i_p_y_n_b
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _P_y_t_h_o_n_ _s_o_u_r_c_e_ _c_o_d_e_:_ _s_e_r_i_a_l_i_z_a_t_i_o_n___a_n_d___w_r_a_p_p_e_r_s_._p_y
│ │ │ │ │ _G_a_l_l_e_r_y_ _g_e_n_e_r_a_t_e_d_ _b_y_ _S_p_h_i_n_x_-_G_a_l_l_e_r_y
│ │ │ │ │ _[_L_o_g_o_]
│ │ │ │ │ ******** NNaavviiggaattiioonn ********
│ │ │ │ │ User manual
│ │ │ │ │ * _W_h_y_ _j_o_b_l_i_b_:_ _p_r_o_j_e_c_t_ _g_o_a_l_s
│ │ │ ├── ./usr/share/doc/python-joblib-doc/html/searchindex.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -729,40 +729,38 @@
│ │ │ │ │ "2": "py:method",
│ │ │ │ │ "3": "py:function"
│ │ │ │ │ },
│ │ │ │ │ "terms": {
│ │ │ │ │ "": [0, 3, 4, 7, 8, 9, 10, 11, 12, 19, 21, 22, 23],
│ │ │ │ │ "0": [3, 4, 6, 7, 8, 9, 11, 12, 13, 16, 17, 19, 21, 22, 24],
│ │ │ │ │ "00": 3,
│ │ │ │ │ - "004": 9,
│ │ │ │ │ "005": 7,
│ │ │ │ │ "0064": 21,
│ │ │ │ │ "01": [0, 4, 7, 10],
│ │ │ │ │ "02": [0, 10],
│ │ │ │ │ - "03": [0, 3, 10],
│ │ │ │ │ + "03": [0, 10],
│ │ │ │ │ "04": [0, 4, 10],
│ │ │ │ │ - "05": [0, 10],
│ │ │ │ │ - "07": [0, 3, 10],
│ │ │ │ │ - "08": [3, 21],
│ │ │ │ │ - "081": 9,
│ │ │ │ │ + "05": [0, 3, 10],
│ │ │ │ │ + "052": 6,
│ │ │ │ │ + "07": [0, 10],
│ │ │ │ │ + "08": 21,
│ │ │ │ │ "09": [0, 10],
│ │ │ │ │ "0b2": [0, 10],
│ │ │ │ │ "0b4": [0, 10],
│ │ │ │ │ "0bn": [0, 10],
│ │ │ │ │ "0min": 19,
│ │ │ │ │ "0x80": 24,
│ │ │ │ │ "1": [1, 3, 4, 6, 7, 8, 9, 11, 12, 16, 17, 19, 21, 22, 23, 24],
│ │ │ │ │ "10": [3, 8, 12, 13, 16, 17, 19, 22, 24],
│ │ │ │ │ "100": [12, 22],
│ │ │ │ │ "1000": 22,
│ │ │ │ │ "10000": 6,
│ │ │ │ │ "1000000": [9, 22, 23],
│ │ │ │ │ "100mb": [0, 6, 10],
│ │ │ │ │ "1018": [0, 10],
│ │ │ │ │ - "102": 7,
│ │ │ │ │ "1024": 24,
│ │ │ │ │ "1025": [0, 10],
│ │ │ │ │ "1038": 24,
│ │ │ │ │ "104": [0, 10],
│ │ │ │ │ "105": [0, 10],
│ │ │ │ │ "1055": [0, 10],
│ │ │ │ │ "1061": [0, 10],
│ │ │ │ │ @@ -780,15 +778,14 @@
│ │ │ │ │ "1176": 24,
│ │ │ │ │ "1181": [0, 10],
│ │ │ │ │ "12": [4, 9, 11, 12, 21, 22],
│ │ │ │ │ "1200": [0, 10],
│ │ │ │ │ "1214": [0, 10],
│ │ │ │ │ "1218": [0, 10],
│ │ │ │ │ "122": 9,
│ │ │ │ │ - "125": 9,
│ │ │ │ │ "1254": [0, 10],
│ │ │ │ │ "1256": [0, 10],
│ │ │ │ │ "1263": [0, 10],
│ │ │ │ │ "1269": [0, 10],
│ │ │ │ │ "128": 24,
│ │ │ │ │ "12934": [12, 22],
│ │ │ │ │ "12_joblib": 9,
│ │ │ │ │ @@ -802,15 +799,15 @@
│ │ │ │ │ "1374": [0, 10],
│ │ │ │ │ "1382": [0, 10],
│ │ │ │ │ "1382643": 3,
│ │ │ │ │ "1392": [0, 10],
│ │ │ │ │ "1393": [0, 10],
│ │ │ │ │ "1394": [0, 10],
│ │ │ │ │ "1395": [0, 10],
│ │ │ │ │ - "14": [7, 22],
│ │ │ │ │ + "14": [3, 22],
│ │ │ │ │ "1400": [0, 10],
│ │ │ │ │ "1411": [0, 10],
│ │ │ │ │ "1422": [0, 10],
│ │ │ │ │ "1427": [0, 10],
│ │ │ │ │ "1433": [0, 10],
│ │ │ │ │ "1447": [0, 10],
│ │ │ │ │ "1451": [0, 10],
│ │ │ │ │ @@ -826,18 +823,20 @@
│ │ │ │ │ "1494": [0, 10],
│ │ │ │ │ "15": 3,
│ │ │ │ │ "150": 6,
│ │ │ │ │ "1595": 9,
│ │ │ │ │ "15mb": 6,
│ │ │ │ │ "16": [21, 24],
│ │ │ │ │ "1699": 9,
│ │ │ │ │ + "17": 7,
│ │ │ │ │ "1734": 9,
│ │ │ │ │ "18": [0, 10],
│ │ │ │ │ "19": [0, 10],
│ │ │ │ │ "1952": 9,
│ │ │ │ │ + "198": 9,
│ │ │ │ │ "1e2": [22, 23],
│ │ │ │ │ "1e4": [4, 22, 23],
│ │ │ │ │ "1e5": [3, 7],
│ │ │ │ │ "1e6": [6, 22, 23],
│ │ │ │ │ "1e7": [6, 7],
│ │ │ │ │ "1e8": 6,
│ │ │ │ │ "1e9": 6,
│ │ │ │ │ @@ -848,47 +847,46 @@
│ │ │ │ │ "200": 6,
│ │ │ │ │ "2010": [0, 10],
│ │ │ │ │ "2011": [0, 10],
│ │ │ │ │ "2012": [0, 10, 12, 22],
│ │ │ │ │ "2013": [0, 10],
│ │ │ │ │ "2014": [0, 10],
│ │ │ │ │ "2022": [0, 10],
│ │ │ │ │ - "21": [0, 6, 9, 10],
│ │ │ │ │ + "205": 6,
│ │ │ │ │ + "21": [0, 9, 10],
│ │ │ │ │ "22": [0, 10],
│ │ │ │ │ "220": [0, 10],
│ │ │ │ │ - "222": 6,
│ │ │ │ │ - "223": 8,
│ │ │ │ │ - "22mb": 6,
│ │ │ │ │ + "225": 9,
│ │ │ │ │ "23": [0, 10],
│ │ │ │ │ "23413696": 3,
│ │ │ │ │ "23415337": 3,
│ │ │ │ │ "24": [0, 10, 22, 23],
│ │ │ │ │ "243": [0, 10],
│ │ │ │ │ "25": [0, 10],
│ │ │ │ │ - "250": 3,
│ │ │ │ │ "254": [0, 10],
│ │ │ │ │ "26": [0, 10],
│ │ │ │ │ "260": [0, 10],
│ │ │ │ │ "269": [0, 10],
│ │ │ │ │ "27": [0, 10],
│ │ │ │ │ - "271": 9,
│ │ │ │ │ + "29": 6,
│ │ │ │ │ "292": [0, 10],
│ │ │ │ │ "294": [0, 10],
│ │ │ │ │ "296": [0, 10],
│ │ │ │ │ "2f": [3, 4, 6, 7],
│ │ │ │ │ "2gb": 6,
│ │ │ │ │ "3": [1, 7, 8, 9, 12, 13, 16, 17, 19, 21, 22, 23, 24],
│ │ │ │ │ "30": [0, 10],
│ │ │ │ │ "300mb": 6,
│ │ │ │ │ "306": [0, 10],
│ │ │ │ │ "31": [0, 10],
│ │ │ │ │ "316": [0, 10],
│ │ │ │ │ "351": [0, 10],
│ │ │ │ │ - "354": [0, 9, 10],
│ │ │ │ │ + "354": [0, 10],
│ │ │ │ │ "37": [12, 22],
│ │ │ │ │ + "37mb": 6,
│ │ │ │ │ "382": [0, 10],
│ │ │ │ │ "384": [0, 10],
│ │ │ │ │ "3f": 9,
│ │ │ │ │ "3rd": [0, 10],
│ │ │ │ │ "4": [1, 4, 8, 12, 16, 17, 19, 21, 22, 24],
│ │ │ │ │ "40": 21,
│ │ │ │ │ "406": [0, 10],
│ │ │ │ │ @@ -899,136 +897,138 @@
│ │ │ │ │ "422": [12, 22],
│ │ │ │ │ "423": [12, 22],
│ │ │ │ │ "424": [12, 22],
│ │ │ │ │ "425": [12, 22],
│ │ │ │ │ "426": [9, 12, 22],
│ │ │ │ │ "427": [12, 22],
│ │ │ │ │ "428": [12, 22],
│ │ │ │ │ + "44gb": 6,
│ │ │ │ │ "451": [0, 10],
│ │ │ │ │ "453": 24,
│ │ │ │ │ + "457": 3,
│ │ │ │ │ "46": [12, 22],
│ │ │ │ │ "462": 24,
│ │ │ │ │ "46947439": 3,
│ │ │ │ │ - "46gb": 6,
│ │ │ │ │ - "482": 6,
│ │ │ │ │ "483": [0, 10],
│ │ │ │ │ "490": [0, 10],
│ │ │ │ │ "49671415": 3,
│ │ │ │ │ - "49901745": 7,
│ │ │ │ │ - "49912523": 7,
│ │ │ │ │ - "49912842": 7,
│ │ │ │ │ - "49926774": 7,
│ │ │ │ │ - "49940142": 7,
│ │ │ │ │ - "49941395": 7,
│ │ │ │ │ - "49942869": 7,
│ │ │ │ │ - "49959472": 7,
│ │ │ │ │ - "49960865": 7,
│ │ │ │ │ - "49962744": 7,
│ │ │ │ │ - "49965952": 7,
│ │ │ │ │ - "49966103": 7,
│ │ │ │ │ - "49968439": 7,
│ │ │ │ │ - "49971614": 7,
│ │ │ │ │ - "49971744": 7,
│ │ │ │ │ - "49976529": 7,
│ │ │ │ │ - "49977758": 7,
│ │ │ │ │ - "49979556": 7,
│ │ │ │ │ - "4997972": 7,
│ │ │ │ │ - "49980701": 7,
│ │ │ │ │ - "49982563": 7,
│ │ │ │ │ - "4998288": 7,
│ │ │ │ │ - "49982882": 7,
│ │ │ │ │ - "49982899": 7,
│ │ │ │ │ - "49982929": 7,
│ │ │ │ │ - "49985216": 7,
│ │ │ │ │ - "49985674": 7,
│ │ │ │ │ - "4998642": 7,
│ │ │ │ │ - "49987477": 7,
│ │ │ │ │ - "49987738": 7,
│ │ │ │ │ - "49988646": 7,
│ │ │ │ │ - "49990027": 7,
│ │ │ │ │ - "499925": 7,
│ │ │ │ │ - "49993302": 7,
│ │ │ │ │ - "49994434": 7,
│ │ │ │ │ - "49994505": 7,
│ │ │ │ │ - "4999466": 7,
│ │ │ │ │ - "49995719": 7,
│ │ │ │ │ - "49995818": 7,
│ │ │ │ │ - "49995878": 7,
│ │ │ │ │ - "49995932": 7,
│ │ │ │ │ - "49998865": 7,
│ │ │ │ │ - "49999139": 7,
│ │ │ │ │ + "49913659": 7,
│ │ │ │ │ + "49920954": 7,
│ │ │ │ │ + "49932607": 7,
│ │ │ │ │ + "49934186": 7,
│ │ │ │ │ + "49939561": 7,
│ │ │ │ │ + "49944284": 7,
│ │ │ │ │ + "49944395": 7,
│ │ │ │ │ + "49953756": 7,
│ │ │ │ │ + "49954083": 7,
│ │ │ │ │ + "49960008": 7,
│ │ │ │ │ + "49960626": 7,
│ │ │ │ │ + "49963753": 7,
│ │ │ │ │ + "49966461": 7,
│ │ │ │ │ + "49967059": 7,
│ │ │ │ │ + "49969885": 7,
│ │ │ │ │ + "49970667": 7,
│ │ │ │ │ + "49973114": 7,
│ │ │ │ │ + "49975728": 7,
│ │ │ │ │ + "4997693": 7,
│ │ │ │ │ + "49978064": 7,
│ │ │ │ │ + "49982308": 7,
│ │ │ │ │ + "49983024": 7,
│ │ │ │ │ + "499834": 7,
│ │ │ │ │ + "49983663": 7,
│ │ │ │ │ + "49983744": 7,
│ │ │ │ │ + "49983866": 7,
│ │ │ │ │ + "49984857": 7,
│ │ │ │ │ + "49985783": 7,
│ │ │ │ │ + "49988861": 7,
│ │ │ │ │ + "49990411": 7,
│ │ │ │ │ + "49991468": 7,
│ │ │ │ │ + "49992475": 7,
│ │ │ │ │ + "49993566": 7,
│ │ │ │ │ + "49994346": 7,
│ │ │ │ │ + "49996148": 7,
│ │ │ │ │ + "49996296": 7,
│ │ │ │ │ + "49997494": 7,
│ │ │ │ │ + "49997927": 7,
│ │ │ │ │ "5": [3, 8, 12, 16, 17, 19, 21, 22, 23, 24],
│ │ │ │ │ "50": [12, 17, 22],
│ │ │ │ │ - "50000787": 7,
│ │ │ │ │ - "50001063": 7,
│ │ │ │ │ - "50003125": 7,
│ │ │ │ │ - "50003677": 7,
│ │ │ │ │ - "50011544": 7,
│ │ │ │ │ - "50012925": 7,
│ │ │ │ │ - "50015474": 7,
│ │ │ │ │ - "50017405": 7,
│ │ │ │ │ - "50018477": 7,
│ │ │ │ │ - "50019762": 7,
│ │ │ │ │ - "50023403": 7,
│ │ │ │ │ - "50024927": 7,
│ │ │ │ │ - "50026159": 7,
│ │ │ │ │ - "50028029": 7,
│ │ │ │ │ - "50035265": 7,
│ │ │ │ │ - "50035478": 7,
│ │ │ │ │ - "5003558": 7,
│ │ │ │ │ - "50036408": 7,
│ │ │ │ │ - "50036893": 7,
│ │ │ │ │ - "50038158": 7,
│ │ │ │ │ - "5003823": 7,
│ │ │ │ │ - "50038923": 7,
│ │ │ │ │ - "5004066": 7,
│ │ │ │ │ - "50047833": 7,
│ │ │ │ │ - "50047847": 7,
│ │ │ │ │ - "50049419": 7,
│ │ │ │ │ - "50049655": 7,
│ │ │ │ │ - "50049757": 7,
│ │ │ │ │ - "50053941": 7,
│ │ │ │ │ - "50055318": 7,
│ │ │ │ │ - "50060994": 7,
│ │ │ │ │ - "50063408": 7,
│ │ │ │ │ - "50065387": 7,
│ │ │ │ │ - "50065458": 7,
│ │ │ │ │ - "50068091": 7,
│ │ │ │ │ - "5006869": 7,
│ │ │ │ │ - "50069688": 7,
│ │ │ │ │ - "50072066": 7,
│ │ │ │ │ - "50073043": 7,
│ │ │ │ │ - "5007343": 7,
│ │ │ │ │ - "50080119": 7,
│ │ │ │ │ - "50080443": 7,
│ │ │ │ │ - "50092615": 7,
│ │ │ │ │ - "50092796": 7,
│ │ │ │ │ - "50096471": 7,
│ │ │ │ │ - "5010889": 7,
│ │ │ │ │ - "50115021": 7,
│ │ │ │ │ - "5012061": 7,
│ │ │ │ │ - "50129073": 7,
│ │ │ │ │ - "50129999": 7,
│ │ │ │ │ - "50133587": 7,
│ │ │ │ │ - "50153887": 7,
│ │ │ │ │ + "50000375": 7,
│ │ │ │ │ + "50002477": 7,
│ │ │ │ │ + "50003576": 7,
│ │ │ │ │ + "50004322": 7,
│ │ │ │ │ + "50004809": 7,
│ │ │ │ │ + "50005738": 7,
│ │ │ │ │ + "50005839": 7,
│ │ │ │ │ + "50006498": 7,
│ │ │ │ │ + "50007196": 7,
│ │ │ │ │ + "5000788": 7,
│ │ │ │ │ + "5000804": 7,
│ │ │ │ │ + "50008124": 7,
│ │ │ │ │ + "50008999": 7,
│ │ │ │ │ + "5001036": 7,
│ │ │ │ │ + "50011265": 7,
│ │ │ │ │ + "50011895": 7,
│ │ │ │ │ + "50012113": 7,
│ │ │ │ │ + "50012483": 7,
│ │ │ │ │ + "50012522": 7,
│ │ │ │ │ + "50013094": 7,
│ │ │ │ │ + "50014462": 7,
│ │ │ │ │ + "50015857": 7,
│ │ │ │ │ + "50017541": 7,
│ │ │ │ │ + "50017806": 7,
│ │ │ │ │ + "50020247": 7,
│ │ │ │ │ + "50020877": 7,
│ │ │ │ │ + "50021018": 7,
│ │ │ │ │ + "50023274": 7,
│ │ │ │ │ + "50023468": 7,
│ │ │ │ │ + "50023869": 7,
│ │ │ │ │ + "50023874": 7,
│ │ │ │ │ + "5002561": 7,
│ │ │ │ │ + "50026771": 7,
│ │ │ │ │ + "5002726": 7,
│ │ │ │ │ + "50027288": 7,
│ │ │ │ │ + "50027415": 7,
│ │ │ │ │ + "50029273": 7,
│ │ │ │ │ + "50030957": 7,
│ │ │ │ │ + "50033152": 7,
│ │ │ │ │ + "5003757": 7,
│ │ │ │ │ + "50039096": 7,
│ │ │ │ │ + "50041713": 7,
│ │ │ │ │ + "50046508": 7,
│ │ │ │ │ + "50048081": 7,
│ │ │ │ │ + "50048643": 7,
│ │ │ │ │ + "50048808": 7,
│ │ │ │ │ + "50049907": 7,
│ │ │ │ │ + "50055421": 7,
│ │ │ │ │ + "50057375": 7,
│ │ │ │ │ + "50058012": 7,
│ │ │ │ │ + "50058719": 7,
│ │ │ │ │ + "50060266": 7,
│ │ │ │ │ + "50063409": 7,
│ │ │ │ │ + "50066718": 7,
│ │ │ │ │ + "50069914": 7,
│ │ │ │ │ + "50070235": 7,
│ │ │ │ │ + "50091316": 7,
│ │ │ │ │ + "519": 8,
│ │ │ │ │ "52201": 21,
│ │ │ │ │ "52302986": 3,
│ │ │ │ │ "54256004": 3,
│ │ │ │ │ "55": [0, 10],
│ │ │ │ │ - "574": 24,
│ │ │ │ │ + "574": [7, 24],
│ │ │ │ │ "57921282": 3,
│ │ │ │ │ "596": 22,
│ │ │ │ │ "5e5": 7,
│ │ │ │ │ "6": [1, 8, 12, 19, 22, 24],
│ │ │ │ │ - "61": 7,
│ │ │ │ │ + "63": 7,
│ │ │ │ │ "64": [0, 10],
│ │ │ │ │ "643": [0, 10],
│ │ │ │ │ "64768854": 3,
│ │ │ │ │ - "69": 4,
│ │ │ │ │ + "696": 9,
│ │ │ │ │ "7": [1, 8, 12, 19, 20, 21, 22, 24],
│ │ │ │ │ + "71": 4,
│ │ │ │ │ "715": [0, 10],
│ │ │ │ │ "716": [0, 10],
│ │ │ │ │ "72": [0, 10],
│ │ │ │ │ "720": [0, 10],
│ │ │ │ │ "721": [0, 10],
│ │ │ │ │ "722": [0, 10],
│ │ │ │ │ "723": [0, 10],
│ │ │ │ │ @@ -1037,31 +1037,32 @@
│ │ │ │ │ "746": [0, 10],
│ │ │ │ │ "747": [0, 10],
│ │ │ │ │ "751": [0, 10],
│ │ │ │ │ "754": 9,
│ │ │ │ │ "76743473": 3,
│ │ │ │ │ "77": 21,
│ │ │ │ │ "784": [0, 10],
│ │ │ │ │ - "785": 4,
│ │ │ │ │ - "79": 7,
│ │ │ │ │ "792": [0, 10],
│ │ │ │ │ "8": [4, 8, 12, 19, 21, 22, 24],
│ │ │ │ │ "8000000": [22, 23],
│ │ │ │ │ + "818": 4,
│ │ │ │ │ "820": [0, 10],
│ │ │ │ │ "833": [0, 10],
│ │ │ │ │ "836": [0, 10],
│ │ │ │ │ "847": [0, 10],
│ │ │ │ │ "858": 24,
│ │ │ │ │ + "873": 9,
│ │ │ │ │ "878": [0, 10],
│ │ │ │ │ "879": [0, 10],
│ │ │ │ │ "886": 24,
│ │ │ │ │ "893": [0, 10],
│ │ │ │ │ "899": [0, 10],
│ │ │ │ │ "9": [8, 11, 12, 13, 19, 21, 22, 24],
│ │ │ │ │ "903": [0, 10],
│ │ │ │ │ + "91": 7,
│ │ │ │ │ "914": [0, 10],
│ │ │ │ │ "920": [0, 10],
│ │ │ │ │ "934": [0, 10],
│ │ │ │ │ "940": [0, 10],
│ │ │ │ │ "951": [0, 10],
│ │ │ │ │ "965": [0, 10],
│ │ │ │ │ "966": [0, 10],