Clean-up the cache folder¶
│ │ │ │memory.clear(warn=False)
│ │ │ │ Total running time of the script: (0 minutes 12.522 seconds)
│ │ │ │ +Total running time of the script: (0 minutes 12.270 seconds)
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -59,30 +59,30 @@
│ │ │ │ │ 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.43 s
│ │ │ │ │ +Elapsed time for the entire processing: 4.23 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)
│ │ │ │ │ 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('\nSecond round - reloading from the cache')
│ │ │ │ │ print('Elapsed time for the entire processing: {:.2f} s'
│ │ │ │ │ .format(_s_t_o_p - _s_t_a_r_t))
│ │ │ │ │ Second round - reloading from the cache
│ │ │ │ │ -Elapsed time for the entire processing: 0.02 s
│ │ │ │ │ +Elapsed time for the entire processing: 0.01 s
│ │ │ │ │ ********** RReeuussee iinntteerrmmeeddiiaattee cchheecckkppooiinnttss_?¶ **********
│ │ │ │ │ Having cached the intermediate results of the costly_compute_cached
│ │ │ │ │ function, they are reusable by calling the function. We define a new
│ │ │ │ │ processing which will take the maximum of the array returned by
│ │ │ │ │ costly_compute_cached instead of previously the mean.
│ │ │ │ │ def data_processing_max_using_cache(_d_a_t_a, column):
│ │ │ │ │ """Compute the max of a column."""
│ │ │ │ │ @@ -95,20 +95,20 @@
│ │ │ │ │ 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('\nReusing intermediate checkpoints')
│ │ │ │ │ print('Elapsed time for the entire processing: {:.2f} s'
│ │ │ │ │ .format(_s_t_o_p - _s_t_a_r_t))
│ │ │ │ │ Reusing intermediate checkpoints
│ │ │ │ │ -Elapsed time for the entire processing: 0.02 s
│ │ │ │ │ +Elapsed time for the entire processing: 0.01 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.522 seconds)
│ │ │ │ │ +TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 12.270 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
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _z_i_p_p_e_d_:_ _n_e_s_t_e_d___p_a_r_a_l_l_e_l___m_e_m_o_r_y_._z_i_p
│ │ │ │ │ _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
│ │ │ ├── ./usr/share/doc/python-joblib-doc/html/auto_examples/parallel_generator.html
│ │ │ │ @@ -144,15 +144,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.42GB
│ │ │ │ +Peak memory usage: 2.40GB
│ │ │ │ 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()
│ │ │ │ @@ -170,15 +170,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: 115.20MB
│ │ │ │ +Peak memory usage: 96.19MB
│ │ │ │ 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 │ │ │ │ @@ -256,15 +256,15 @@ │ │ │ │ peak = max(monitor_delayed_gen.memory_buffer) / 1e6 │ │ │ │ print(f"Peak memory usage: {peak:.2f}MB") │ │ │ │ │ │ │ │ │ │ │ │
Create result generator on delayed tasks with return_as='generator'...
│ │ │ │ Accumulate results:......................................................................................................................................................
│ │ │ │ All tasks completed and reduced successfully.
│ │ │ │ -Peak memory usage: 251.92MB
│ │ │ │ +Peak memory usage: 353.20MB
│ │ │ │ If we use return_as="generator_unordered", res will not enforce any
│ │ │ │ order when returning the results, and will simply enable iterating on the
│ │ │ │ results as soon as it’s available. The peak memory usage is now controlled
│ │ │ │ to an even lower level, since that results can be consumed immediately
│ │ │ │ rather than being delayed by the compute of slower tasks that have been
│ │ │ │ @@ -287,15 +287,15 @@
│ │ │ │ peak = max(monitor_delayed_gen_unordered.memory_buffer) / 1e6
│ │ │ │ print(f"Peak memory usage: {peak:.2f}MB")
│ │ │ │
│ │ │ │
│ │ │ │
Create result generator on delayed tasks with return_as='generator_unordered'...
│ │ │ │ Accumulate results:......................................................................................................................................................
│ │ │ │ All tasks completed and reduced successfully.
│ │ │ │ -Peak memory usage: 112.89MB
│ │ │ │ +Peak memory usage: 79.99MB
│ │ │ │ Notice how the plot for 'return_as="generator' now shows a high memory
│ │ │ │ usage plateau when slow jobs cause a congestion of intermediate results
│ │ │ │ waiting in RAM before in-order aggregation. This high memory usage is never
│ │ │ │ observed when using 'return_as="generator_unordered".
plt.figure(1)
│ │ │ │ @@ -311,15 +311,15 @@
│ │ │ │ plt.xticks([], [])
│ │ │ │ plt.ylabel("Memory usage")
│ │ │ │ plt.yticks([1e7, 1e8, 1e9], ['10MB', '100MB', '1GB'])
│ │ │ │ plt.legend()
│ │ │ │ plt.show()
│ │ │ │ 
Total running time of the script: (2 minutes 30.335 seconds)
│ │ │ │ +Total running time of the script: (1 minutes 34.485 seconds)
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -91,15 +91,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.42GB
│ │ │ │ │ +Peak memory usage: 2.40GB
│ │ │ │ │ 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")(
│ │ │ │ │ @@ -114,15 +114,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: 115.20MB
│ │ │ │ │ +Peak memory usage: 96.19MB
│ │ │ │ │ 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.
│ │ │ │ │ @@ -191,15 +191,15 @@
│ │ │ │ │ _m_o_n_i_t_o_r___d_e_l_a_y_e_d___g_e_n_._j_o_i_n()
│ │ │ │ │ _p_e_a_k = max(_m_o_n_i_t_o_r___d_e_l_a_y_e_d___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 on delayed tasks with return_as='generator'...
│ │ │ │ │ Accumulate
│ │ │ │ │ results:......................................................................................................................................................
│ │ │ │ │ All tasks completed and reduced successfully.
│ │ │ │ │ -Peak memory usage: 251.92MB
│ │ │ │ │ +Peak memory usage: 353.20MB
│ │ │ │ │ If we use return_as="generator_unordered", res will not enforce any order when
│ │ │ │ │ returning the results, and will simply enable iterating on the results as soon
│ │ │ │ │ as it’s available. The peak memory usage is now controlled to an even lower
│ │ │ │ │ level, since that results can be consumed immediately rather than being delayed
│ │ │ │ │ by the compute of slower tasks that have been submitted earlier.
│ │ │ │ │ monitor_delayed_gen_unordered = _M_e_m_o_r_y_M_o_n_i_t_o_r()
│ │ │ │ │ print(
│ │ │ │ │ @@ -219,15 +219,15 @@
│ │ │ │ │ _p_e_a_k = max(_m_o_n_i_t_o_r___d_e_l_a_y_e_d___g_e_n___u_n_o_r_d_e_r_e_d_._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 on delayed tasks with
│ │ │ │ │ return_as='generator_unordered'...
│ │ │ │ │ Accumulate
│ │ │ │ │ results:......................................................................................................................................................
│ │ │ │ │ All tasks completed and reduced successfully.
│ │ │ │ │ -Peak memory usage: 112.89MB
│ │ │ │ │ +Peak memory usage: 79.99MB
│ │ │ │ │ Notice how the plot for 'return_as="generator' now shows a high memory usage
│ │ │ │ │ plateau when slow jobs cause a congestion of intermediate results waiting in
│ │ │ │ │ RAM before in-order aggregation. This high memory usage is never observed when
│ │ │ │ │ using 'return_as="generator_unordered".
│ │ │ │ │ plt.figure(1)
│ │ │ │ │ plt.semilogy(
│ │ │ │ │ np.maximum.accumulate(_m_o_n_i_t_o_r___d_e_l_a_y_e_d___g_e_n_._m_e_m_o_r_y___b_u_f_f_e_r),
│ │ │ │ │ @@ -240,15 +240,15 @@
│ │ │ │ │ plt.xlabel("Time")
│ │ │ │ │ plt.xticks([], [])
│ │ │ │ │ plt.ylabel("Memory usage")
│ │ │ │ │ plt.yticks([1e7, 1e8, 1e9], ['10MB', '100MB', '1GB'])
│ │ │ │ │ plt.legend()
│ │ │ │ │ plt.show()
│ │ │ │ │ [parallel generator]
│ │ │ │ │ -TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (2 minutes 30.335 seconds)
│ │ │ │ │ +TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (1 minutes 34.485 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
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _z_i_p_p_e_d_:_ _p_a_r_a_l_l_e_l___g_e_n_e_r_a_t_o_r_._z_i_p
│ │ │ │ │ _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
│ │ │ ├── ./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.06 s
│ │ │ │ +Elapsed time computing the average of couple of slices 1.01 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.96 s
│ │ │ │ +Elapsed time computing the average of couple of slices 0.76 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.57 s
│ │ │ │ +Elapsed time computing the average of couple of slices 0.53 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.50022324 0.50020858 0.50001355 0.50013202 0.50004606 0.49977811
│ │ │ │ - 0.49988015 0.49997704 0.49982581 0.49973486 0.49995341 0.49980902
│ │ │ │ - 0.49949566 0.49937467 0.49967214 0.49976548 0.49976194 0.50020776
│ │ │ │ - 0.50038899 0.50011647 0.50002963 0.49985226 0.49932031 0.49908126
│ │ │ │ - 0.49927974 0.49948344 0.49967835 0.49982657 0.49997197 0.49983018
│ │ │ │ - 0.49959321 0.4995852 0.50023201 0.50041353 0.50055207 0.50035156
│ │ │ │ - 0.50036362 0.49986384 0.49966756 0.49931744 0.49955731 0.49983616
│ │ │ │ - 0.49994573 0.4997858 0.50023991 0.50010509 0.49952633 0.4997366
│ │ │ │ - 0.50001362 0.50010194 0.50003621 0.50003417 0.49971064 0.49955131
│ │ │ │ - 0.49947763 0.49991273 0.50016722 0.50032566 0.50013786 0.50018219
│ │ │ │ - 0.50035467 0.50041366 0.50041905 0.50055501 0.50034893 0.49986393
│ │ │ │ - 0.49984693 0.49970628 0.49960139 0.49942702 0.49991124 0.49988748
│ │ │ │ - 0.49980347 0.50023952 0.50052783 0.50009461 0.50046984 0.50040682
│ │ │ │ - 0.50037031 0.50054301 0.50043676 0.4998841 0.50012712 0.50013579
│ │ │ │ - 0.50000409 0.49989946 0.50032194 0.50052522 0.5007307 0.50039103
│ │ │ │ - 0.50046139 0.5004464 0.50021111 0.49976686 0.500073 ]
│ │ │ │ + [0.50020532 0.50012674 0.49994382 0.49972443 0.4997981 0.50003744
│ │ │ │ + 0.50012584 0.49996749 0.5001114 0.50030163 0.50015622 0.50014606
│ │ │ │ + 0.50009855 0.50002205 0.49946124 0.49925254 0.49925254 0.49923245
│ │ │ │ + 0.4993102 0.49924509 0.49937063 0.49930827 0.49935984 0.49933691
│ │ │ │ + 0.49947721 0.5003727 0.50037977 0.50066993 0.50086629 0.50088083
│ │ │ │ + 0.50049967 0.50073542 0.50036696 0.49972526 0.49981844 0.4992151
│ │ │ │ + 0.49904149 0.49906411 0.49966002 0.49978763 0.49953333 0.49991988
│ │ │ │ + 0.50021549 0.50021544 0.50036392 0.50065175 0.50071049 0.50085892
│ │ │ │ + 0.50074385 0.50022806 0.50034574 0.49975994 0.49952333 0.4992846
│ │ │ │ + 0.49920768 0.49865546 0.49885528 0.49907251 0.49951036 0.49997401
│ │ │ │ + 0.50057558 0.50078551 0.50055758 0.50047903 0.50023936 0.50025688
│ │ │ │ + 0.49986162 0.49979383 0.4995025 0.49964931 0.49957269 0.4999394
│ │ │ │ + 0.5001625 0.50016773 0.50015811 0.50040871 0.50025128 0.49977067
│ │ │ │ + 0.50001192 0.50030671 0.5004472 0.50030899 0.50070401 0.50068896
│ │ │ │ + 0.50017199 0.49971073 0.49967689 0.49984616 0.49982452 0.50021516
│ │ │ │ + 0.50015157 0.50035458 0.50021465 0.50016187 0.49979703]
│ │ │ │
│ │ │ │ Actual means computed by the worker processes:
│ │ │ │ - [0.50022324 0.50020858 0.50001355 0.50013202 0.50004606 0.49977811
│ │ │ │ - 0.49988015 0.49997704 0.49982581 0.49973486 0.49995341 0.49980902
│ │ │ │ - 0.49949566 0.49937467 0.49967214 0.49976548 0.49976194 0.50020776
│ │ │ │ - 0.50038899 0.50011647 0.50002963 0.49985226 0.49932031 0.49908126
│ │ │ │ - 0.49927974 0.49948344 0.49967835 0.49982657 0.49997197 0.49983018
│ │ │ │ - 0.49959321 0.4995852 0.50023201 0.50041353 0.50055207 0.50035156
│ │ │ │ - 0.50036362 0.49986384 0.49966756 0.49931744 0.49955731 0.49983616
│ │ │ │ - 0.49994573 0.4997858 0.50023991 0.50010509 0.49952633 0.4997366
│ │ │ │ - 0.50001362 0.50010194 0.50003621 0.50003417 0.49971064 0.49955131
│ │ │ │ - 0.49947763 0.49991273 0.50016722 0.50032566 0.50013786 0.50018219
│ │ │ │ - 0.50035467 0.50041366 0.50041905 0.50055501 0.50034893 0.49986393
│ │ │ │ - 0.49984693 0.49970628 0.49960139 0.49942702 0.49991124 0.49988748
│ │ │ │ - 0.49980347 0.50023952 0.50052783 0.50009461 0.50046984 0.50040682
│ │ │ │ - 0.50037031 0.50054301 0.50043676 0.4998841 0.50012712 0.50013579
│ │ │ │ - 0.50000409 0.49989946 0.50032194 0.50052522 0.5007307 0.50039103
│ │ │ │ - 0.50046139 0.5004464 0.50021111 0.49976686 0.500073 ]
│ │ │ │ + [0.50020532 0.50012674 0.49994382 0.49972443 0.4997981 0.50003744
│ │ │ │ + 0.50012584 0.49996749 0.5001114 0.50030163 0.50015622 0.50014606
│ │ │ │ + 0.50009855 0.50002205 0.49946124 0.49925254 0.49925254 0.49923245
│ │ │ │ + 0.4993102 0.49924509 0.49937063 0.49930827 0.49935984 0.49933691
│ │ │ │ + 0.49947721 0.5003727 0.50037977 0.50066993 0.50086629 0.50088083
│ │ │ │ + 0.50049967 0.50073542 0.50036696 0.49972526 0.49981844 0.4992151
│ │ │ │ + 0.49904149 0.49906411 0.49966002 0.49978763 0.49953333 0.49991988
│ │ │ │ + 0.50021549 0.50021544 0.50036392 0.50065175 0.50071049 0.50085892
│ │ │ │ + 0.50074385 0.50022806 0.50034574 0.49975994 0.49952333 0.4992846
│ │ │ │ + 0.49920768 0.49865546 0.49885528 0.49907251 0.49951036 0.49997401
│ │ │ │ + 0.50057558 0.50078551 0.50055758 0.50047903 0.50023936 0.50025688
│ │ │ │ + 0.49986162 0.49979383 0.4995025 0.49964931 0.49957269 0.4999394
│ │ │ │ + 0.5001625 0.50016773 0.50015811 0.50040871 0.50025128 0.49977067
│ │ │ │ + 0.50001192 0.50030671 0.5004472 0.50030899 0.50070401 0.50068896
│ │ │ │ + 0.50017199 0.49971073 0.49967689 0.49984616 0.49982452 0.50021516
│ │ │ │ + 0.50015157 0.50035458 0.50021465 0.50016187 0.49979703]
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ 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 4.335 seconds)
│ │ │ │ +Total running time of the script: (0 minutes 3.389 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.06 s
│ │ │ │ │ +Elapsed time computing the average of couple of slices 1.01 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.96 s
│ │ │ │ │ +Elapsed time computing the average of couple of slices 0.76 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.57 s
│ │ │ │ │ +Elapsed time computing the average of couple of slices 0.53 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.50022324 0.50020858 0.50001355 0.50013202 0.50004606 0.49977811
│ │ │ │ │ - 0.49988015 0.49997704 0.49982581 0.49973486 0.49995341 0.49980902
│ │ │ │ │ - 0.49949566 0.49937467 0.49967214 0.49976548 0.49976194 0.50020776
│ │ │ │ │ - 0.50038899 0.50011647 0.50002963 0.49985226 0.49932031 0.49908126
│ │ │ │ │ - 0.49927974 0.49948344 0.49967835 0.49982657 0.49997197 0.49983018
│ │ │ │ │ - 0.49959321 0.4995852 0.50023201 0.50041353 0.50055207 0.50035156
│ │ │ │ │ - 0.50036362 0.49986384 0.49966756 0.49931744 0.49955731 0.49983616
│ │ │ │ │ - 0.49994573 0.4997858 0.50023991 0.50010509 0.49952633 0.4997366
│ │ │ │ │ - 0.50001362 0.50010194 0.50003621 0.50003417 0.49971064 0.49955131
│ │ │ │ │ - 0.49947763 0.49991273 0.50016722 0.50032566 0.50013786 0.50018219
│ │ │ │ │ - 0.50035467 0.50041366 0.50041905 0.50055501 0.50034893 0.49986393
│ │ │ │ │ - 0.49984693 0.49970628 0.49960139 0.49942702 0.49991124 0.49988748
│ │ │ │ │ - 0.49980347 0.50023952 0.50052783 0.50009461 0.50046984 0.50040682
│ │ │ │ │ - 0.50037031 0.50054301 0.50043676 0.4998841 0.50012712 0.50013579
│ │ │ │ │ - 0.50000409 0.49989946 0.50032194 0.50052522 0.5007307 0.50039103
│ │ │ │ │ - 0.50046139 0.5004464 0.50021111 0.49976686 0.500073 ]
│ │ │ │ │ + [0.50020532 0.50012674 0.49994382 0.49972443 0.4997981 0.50003744
│ │ │ │ │ + 0.50012584 0.49996749 0.5001114 0.50030163 0.50015622 0.50014606
│ │ │ │ │ + 0.50009855 0.50002205 0.49946124 0.49925254 0.49925254 0.49923245
│ │ │ │ │ + 0.4993102 0.49924509 0.49937063 0.49930827 0.49935984 0.49933691
│ │ │ │ │ + 0.49947721 0.5003727 0.50037977 0.50066993 0.50086629 0.50088083
│ │ │ │ │ + 0.50049967 0.50073542 0.50036696 0.49972526 0.49981844 0.4992151
│ │ │ │ │ + 0.49904149 0.49906411 0.49966002 0.49978763 0.49953333 0.49991988
│ │ │ │ │ + 0.50021549 0.50021544 0.50036392 0.50065175 0.50071049 0.50085892
│ │ │ │ │ + 0.50074385 0.50022806 0.50034574 0.49975994 0.49952333 0.4992846
│ │ │ │ │ + 0.49920768 0.49865546 0.49885528 0.49907251 0.49951036 0.49997401
│ │ │ │ │ + 0.50057558 0.50078551 0.50055758 0.50047903 0.50023936 0.50025688
│ │ │ │ │ + 0.49986162 0.49979383 0.4995025 0.49964931 0.49957269 0.4999394
│ │ │ │ │ + 0.5001625 0.50016773 0.50015811 0.50040871 0.50025128 0.49977067
│ │ │ │ │ + 0.50001192 0.50030671 0.5004472 0.50030899 0.50070401 0.50068896
│ │ │ │ │ + 0.50017199 0.49971073 0.49967689 0.49984616 0.49982452 0.50021516
│ │ │ │ │ + 0.50015157 0.50035458 0.50021465 0.50016187 0.49979703]
│ │ │ │ │
│ │ │ │ │ Actual means computed by the worker processes:
│ │ │ │ │ - [0.50022324 0.50020858 0.50001355 0.50013202 0.50004606 0.49977811
│ │ │ │ │ - 0.49988015 0.49997704 0.49982581 0.49973486 0.49995341 0.49980902
│ │ │ │ │ - 0.49949566 0.49937467 0.49967214 0.49976548 0.49976194 0.50020776
│ │ │ │ │ - 0.50038899 0.50011647 0.50002963 0.49985226 0.49932031 0.49908126
│ │ │ │ │ - 0.49927974 0.49948344 0.49967835 0.49982657 0.49997197 0.49983018
│ │ │ │ │ - 0.49959321 0.4995852 0.50023201 0.50041353 0.50055207 0.50035156
│ │ │ │ │ - 0.50036362 0.49986384 0.49966756 0.49931744 0.49955731 0.49983616
│ │ │ │ │ - 0.49994573 0.4997858 0.50023991 0.50010509 0.49952633 0.4997366
│ │ │ │ │ - 0.50001362 0.50010194 0.50003621 0.50003417 0.49971064 0.49955131
│ │ │ │ │ - 0.49947763 0.49991273 0.50016722 0.50032566 0.50013786 0.50018219
│ │ │ │ │ - 0.50035467 0.50041366 0.50041905 0.50055501 0.50034893 0.49986393
│ │ │ │ │ - 0.49984693 0.49970628 0.49960139 0.49942702 0.49991124 0.49988748
│ │ │ │ │ - 0.49980347 0.50023952 0.50052783 0.50009461 0.50046984 0.50040682
│ │ │ │ │ - 0.50037031 0.50054301 0.50043676 0.4998841 0.50012712 0.50013579
│ │ │ │ │ - 0.50000409 0.49989946 0.50032194 0.50052522 0.5007307 0.50039103
│ │ │ │ │ - 0.50046139 0.5004464 0.50021111 0.49976686 0.500073 ]
│ │ │ │ │ + [0.50020532 0.50012674 0.49994382 0.49972443 0.4997981 0.50003744
│ │ │ │ │ + 0.50012584 0.49996749 0.5001114 0.50030163 0.50015622 0.50014606
│ │ │ │ │ + 0.50009855 0.50002205 0.49946124 0.49925254 0.49925254 0.49923245
│ │ │ │ │ + 0.4993102 0.49924509 0.49937063 0.49930827 0.49935984 0.49933691
│ │ │ │ │ + 0.49947721 0.5003727 0.50037977 0.50066993 0.50086629 0.50088083
│ │ │ │ │ + 0.50049967 0.50073542 0.50036696 0.49972526 0.49981844 0.4992151
│ │ │ │ │ + 0.49904149 0.49906411 0.49966002 0.49978763 0.49953333 0.49991988
│ │ │ │ │ + 0.50021549 0.50021544 0.50036392 0.50065175 0.50071049 0.50085892
│ │ │ │ │ + 0.50074385 0.50022806 0.50034574 0.49975994 0.49952333 0.4992846
│ │ │ │ │ + 0.49920768 0.49865546 0.49885528 0.49907251 0.49951036 0.49997401
│ │ │ │ │ + 0.50057558 0.50078551 0.50055758 0.50047903 0.50023936 0.50025688
│ │ │ │ │ + 0.49986162 0.49979383 0.4995025 0.49964931 0.49957269 0.4999394
│ │ │ │ │ + 0.5001625 0.50016773 0.50015811 0.50040871 0.50025128 0.49977067
│ │ │ │ │ + 0.50001192 0.50030671 0.5004472 0.50030899 0.50070401 0.50068896
│ │ │ │ │ + 0.50017199 0.49971073 0.49967689 0.49984616 0.49982452 0.50021516
│ │ │ │ │ + 0.50015157 0.50035458 0.50021465 0.50016187 0.49979703]
│ │ │ │ │ ********** 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 4.335 seconds)
│ │ │ │ │ +TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 3.389 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
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _z_i_p_p_e_d_:_ _p_a_r_a_l_l_e_l___m_e_m_m_a_p_._z_i_p
│ │ │ │ │ _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
│ │ │ ├── ./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:
│ │ │ │ - [[0 6 3 4 2]
│ │ │ │ - [6 2 6 3 0]
│ │ │ │ - [9 4 7 7 3]
│ │ │ │ - [3 4 2 8 6]
│ │ │ │ - [4 9 3 4 2]]
│ │ │ │ + [[9 8 1 2 4]
│ │ │ │ + [5 8 3 6 8]
│ │ │ │ + [9 4 3 8 3]
│ │ │ │ + [0 2 4 2 0]
│ │ │ │ + [2 1 0 6 6]]
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ 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:
│ │ │ │ - [[5 3 7 5 1]
│ │ │ │ - [6 2 2 8 5]
│ │ │ │ - [7 9 2 8 8]
│ │ │ │ - [5 9 9 9 9]
│ │ │ │ - [1 3 5 5 0]]
│ │ │ │ + [[7 1 5 5 4]
│ │ │ │ + [2 0 2 5 8]
│ │ │ │ + [6 8 5 4 1]
│ │ │ │ + [1 8 5 1 8]
│ │ │ │ + [0 9 0 6 2]]
│ │ │ │
│ │ │ │
│ │ │ │ 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:
│ │ │ │ - [[3 4 0 2 2]
│ │ │ │ - [6 9 9 1 2]
│ │ │ │ - [6 1 6 5 0]
│ │ │ │ - [5 4 4 4 2]
│ │ │ │ - [3 3 8 7 8]]
│ │ │ │ + [[3 0 6 3 2]
│ │ │ │ + [5 6 7 2 7]
│ │ │ │ + [0 6 9 6 1]
│ │ │ │ + [3 9 1 2 8]
│ │ │ │ + [8 0 0 3 1]]
│ │ │ │
│ │ │ │
│ │ │ │ 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:
│ │ │ │ - [[5 1 7 0 7]
│ │ │ │ - [5 1 7 0 7]
│ │ │ │ - [4 8 5 0 1]
│ │ │ │ - [4 8 5 0 1]
│ │ │ │ - [3 0 0 1 8]]
│ │ │ │ + [[7 5 2 8 3]
│ │ │ │ + [7 5 2 8 3]
│ │ │ │ + [2 2 7 8 8]
│ │ │ │ + [2 2 7 8 8]
│ │ │ │ + [5 6 0 0 7]]
│ │ │ │
│ │ │ │
│ │ │ │ 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:
│ │ │ │ - [[9 1 4 3 1]
│ │ │ │ - [9 8 2 2 8]
│ │ │ │ - [5 6 1 3 0]
│ │ │ │ - [9 3 8 7 5]
│ │ │ │ - [4 4 7 6 8]]
│ │ │ │ + [[1 2 6 6 9]
│ │ │ │ + [3 7 2 4 8]
│ │ │ │ + [4 0 4 5 6]
│ │ │ │ + [8 1 0 5 8]
│ │ │ │ + [2 0 5 0 9]]
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Fixing the random state to obtain deterministic results¶
│ │ │ │
│ │ │ │ The pattern of stochastic_function_seeded has another advantage: it
│ │ │ │ @@ -215,15 +215,15 @@
│ │ │ │ [[5 7 2 3 5]
│ │ │ │ [1 7 4 0 6]
│ │ │ │ [4 9 5 6 4]
│ │ │ │ [1 8 1 0 4]
│ │ │ │ [8 3 5 7 0]]
│ │ │ │
│ │ │ │
│ │ │ │ -Total running time of the script: (0 minutes 0.407 seconds)
│ │ │ │ +Total running time of the script: (0 minutes 0.242 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:
│ │ │ │ │ - [[0 6 3 4 2]
│ │ │ │ │ - [6 2 6 3 0]
│ │ │ │ │ - [9 4 7 7 3]
│ │ │ │ │ - [3 4 2 8 6]
│ │ │ │ │ - [4 9 3 4 2]]
│ │ │ │ │ + [[9 8 1 2 4]
│ │ │ │ │ + [5 8 3 6 8]
│ │ │ │ │ + [9 4 3 8 3]
│ │ │ │ │ + [0 2 4 2 0]
│ │ │ │ │ + [2 1 0 6 6]]
│ │ │ │ │ ********** 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:
│ │ │ │ │ - [[5 3 7 5 1]
│ │ │ │ │ - [6 2 2 8 5]
│ │ │ │ │ - [7 9 2 8 8]
│ │ │ │ │ - [5 9 9 9 9]
│ │ │ │ │ - [1 3 5 5 0]]
│ │ │ │ │ + [[7 1 5 5 4]
│ │ │ │ │ + [2 0 2 5 8]
│ │ │ │ │ + [6 8 5 4 1]
│ │ │ │ │ + [1 8 5 1 8]
│ │ │ │ │ + [0 9 0 6 2]]
│ │ │ │ │ _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:
│ │ │ │ │ - [[3 4 0 2 2]
│ │ │ │ │ - [6 9 9 1 2]
│ │ │ │ │ - [6 1 6 5 0]
│ │ │ │ │ - [5 4 4 4 2]
│ │ │ │ │ - [3 3 8 7 8]]
│ │ │ │ │ + [[3 0 6 3 2]
│ │ │ │ │ + [5 6 7 2 7]
│ │ │ │ │ + [0 6 9 6 1]
│ │ │ │ │ + [3 9 1 2 8]
│ │ │ │ │ + [8 0 0 3 1]]
│ │ │ │ │ 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:
│ │ │ │ │ - [[5 1 7 0 7]
│ │ │ │ │ - [5 1 7 0 7]
│ │ │ │ │ - [4 8 5 0 1]
│ │ │ │ │ - [4 8 5 0 1]
│ │ │ │ │ - [3 0 0 1 8]]
│ │ │ │ │ + [[7 5 2 8 3]
│ │ │ │ │ + [7 5 2 8 3]
│ │ │ │ │ + [2 2 7 8 8]
│ │ │ │ │ + [2 2 7 8 8]
│ │ │ │ │ + [5 6 0 0 7]]
│ │ │ │ │ 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, random_state):
│ │ │ │ │ @@ -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:
│ │ │ │ │ - [[9 1 4 3 1]
│ │ │ │ │ - [9 8 2 2 8]
│ │ │ │ │ - [5 6 1 3 0]
│ │ │ │ │ - [9 3 8 7 5]
│ │ │ │ │ - [4 4 7 6 8]]
│ │ │ │ │ + [[1 2 6 6 9]
│ │ │ │ │ + [3 7 2 4 8]
│ │ │ │ │ + [4 0 4 5 6]
│ │ │ │ │ + [8 1 0 5 8]
│ │ │ │ │ + [2 0 5 0 9]]
│ │ │ │ │ ********** 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. For best
│ │ │ │ │ results _[_1_], the random state is initialized by a sequence based on a
│ │ │ │ │ root seed and a job identifier. So for instance, we can replicate the
│ │ │ │ │ same generation of vectors by passing a fixed state as follows.
│ │ │ │ │ [_1]
│ │ │ │ │ @@ -126,15 +126,15 @@
│ │ │ │ │
│ │ │ │ │ The different generated vectors using the multiprocessing backend are:
│ │ │ │ │ [[5 7 2 3 5]
│ │ │ │ │ [1 7 4 0 6]
│ │ │ │ │ [4 9 5 6 4]
│ │ │ │ │ [1 8 1 0 4]
│ │ │ │ │ [8 3 5 7 0]]
│ │ │ │ │ -TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 0.407 seconds)
│ │ │ │ │ +TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 0.242 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
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _z_i_p_p_e_d_:_ _p_a_r_a_l_l_e_l___r_a_n_d_o_m___s_t_a_t_e_._z_i_p
│ │ │ │ │ _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
│ │ │ ├── ./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.114s
│ │ │ │ +With loky backend and cloudpickle serialization: 0.084s
│ │ │ │
│ │ │ │
│ │ │ │ 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.216s
│ │ │ │ +With multiprocessing backend and pickle serialization: 0.134s
│ │ │ │
│ │ │ │
│ │ │ │ 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.113s
│ │ │ │ +With pickle serialization: 0.072s
│ │ │ │
│ │ │ │
│ │ │ │ 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
│ │ │ │ @@ -203,28 +203,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.363s
│ │ │ │ +With pickle from stdlib and wrapper: 0.236s
│ │ │ │
│ │ │ │
│ │ │ │ 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 0.946 seconds)
│ │ │ │ +Total running time of the script: (0 minutes 0.630 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.114s
│ │ │ │ │ +With loky backend and cloudpickle serialization: 0.084s
│ │ │ │ │ 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.216s
│ │ │ │ │ +With multiprocessing backend and pickle serialization: 0.134s
│ │ │ │ │ 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.113s
│ │ │ │ │ +With pickle serialization: 0.072s
│ │ │ │ │ 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
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ @@ -148,23 +148,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.363s
│ │ │ │ │ +With pickle from stdlib and wrapper: 0.236s
│ │ │ │ │ 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 0.946 seconds)
│ │ │ │ │ +TToottaall rruunnnniinngg ttiimmee ooff tthhee ssccrriipptt:: (0 minutes 0.630 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
│ │ │ │ │ _D_o_w_n_l_o_a_d_ _z_i_p_p_e_d_:_ _s_e_r_i_a_l_i_z_a_t_i_o_n___a_n_d___w_r_a_p_p_e_r_s_._z_i_p
│ │ │ │ │ _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
│ │ │ ├── ./usr/share/doc/python-joblib-doc/html/searchindex.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -742,20 +742,21 @@
│ │ │ │ │ },
│ │ │ │ │ "terms": {
│ │ │ │ │ "": [0, 3, 4, 6, 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, 4],
│ │ │ │ │ "005": 7,
│ │ │ │ │ "0064": 21,
│ │ │ │ │ - "01": [0, 7, 10],
│ │ │ │ │ - "02": [3, 4],
│ │ │ │ │ + "01": [0, 4, 7, 10],
│ │ │ │ │ + "02": 3,
│ │ │ │ │ "03": [0, 10],
│ │ │ │ │ - "06": 7,
│ │ │ │ │ "07": [0, 10],
│ │ │ │ │ + "072": 9,
│ │ │ │ │ "08": 21,
│ │ │ │ │ + "084": 9,
│ │ │ │ │ "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],
│ │ │ │ │ @@ -774,21 +775,18 @@
│ │ │ │ │ "1055": [0, 10],
│ │ │ │ │ "1061": [0, 10],
│ │ │ │ │ "1062": [0, 10],
│ │ │ │ │ "1078": [0, 10],
│ │ │ │ │ "1093": [0, 10],
│ │ │ │ │ "10mb": 6,
│ │ │ │ │ "11": [12, 22],
│ │ │ │ │ - "112": 6,
│ │ │ │ │ - "113": 9,
│ │ │ │ │ "1133": [0, 10],
│ │ │ │ │ "1136": [0, 10, 22],
│ │ │ │ │ "114": 9,
│ │ │ │ │ "1149": [0, 10],
│ │ │ │ │ - "115": 6,
│ │ │ │ │ "1158": 24,
│ │ │ │ │ "1165": [0, 10],
│ │ │ │ │ "1176": 24,
│ │ │ │ │ "1181": [0, 10],
│ │ │ │ │ "12": [4, 11, 12, 21, 22],
│ │ │ │ │ "120": 9,
│ │ │ │ │ "1200": [0, 10],
│ │ │ │ │ @@ -798,14 +796,15 @@
│ │ │ │ │ "1256": [0, 10],
│ │ │ │ │ "1263": [0, 10],
│ │ │ │ │ "1269": [0, 10],
│ │ │ │ │ "128": 24,
│ │ │ │ │ "12934": [12, 22],
│ │ │ │ │ "13": 9,
│ │ │ │ │ "1327": [0, 10],
│ │ │ │ │ + "134": 9,
│ │ │ │ │ "1343": [0, 10],
│ │ │ │ │ "1348": [0, 10],
│ │ │ │ │ "1353": [0, 10],
│ │ │ │ │ "1356": [0, 10],
│ │ │ │ │ "1359": [0, 10],
│ │ │ │ │ "1361": [0, 10],
│ │ │ │ │ "1374": [0, 10],
│ │ │ │ │ @@ -847,14 +846,16 @@
│ │ │ │ │ "15mb": 6,
│ │ │ │ │ "16": [21, 24],
│ │ │ │ │ "1650": 9,
│ │ │ │ │ "1754": 9,
│ │ │ │ │ "1789": 9,
│ │ │ │ │ "18": [0, 10],
│ │ │ │ │ "19": [0, 10],
│ │ │ │ │ + "195": 3,
│ │ │ │ │ + "19mb": 6,
│ │ │ │ │ "1e2": [22, 23],
│ │ │ │ │ "1e4": [4, 22, 23],
│ │ │ │ │ "1e5": [3, 7],
│ │ │ │ │ "1e6": [6, 22, 23],
│ │ │ │ │ "1e7": [6, 7],
│ │ │ │ │ "1e8": 6,
│ │ │ │ │ "1e9": 6,
│ │ │ │ │ @@ -868,184 +869,183 @@
│ │ │ │ │ "2011": [0, 10],
│ │ │ │ │ "2012": [0, 10, 12, 22],
│ │ │ │ │ "2013": [0, 10],
│ │ │ │ │ "2014": [0, 10],
│ │ │ │ │ "2022": [0, 10],
│ │ │ │ │ "20mb": 6,
│ │ │ │ │ "21": [0, 9, 10],
│ │ │ │ │ - "216": 9,
│ │ │ │ │ "22": [0, 10],
│ │ │ │ │ "220": [0, 10],
│ │ │ │ │ - "23": [0, 10],
│ │ │ │ │ + "23": [0, 4, 10],
│ │ │ │ │ "23413696": 3,
│ │ │ │ │ "23415337": 3,
│ │ │ │ │ + "236": 9,
│ │ │ │ │ "24": [0, 10, 22, 23],
│ │ │ │ │ + "242": 8,
│ │ │ │ │ "243": [0, 10],
│ │ │ │ │ "25": [0, 10],
│ │ │ │ │ - "251": 6,
│ │ │ │ │ "254": [0, 10],
│ │ │ │ │ "26": [0, 10],
│ │ │ │ │ "260": [0, 10],
│ │ │ │ │ - "264": 3,
│ │ │ │ │ "269": [0, 10],
│ │ │ │ │ "27": [0, 10],
│ │ │ │ │ + "270": 4,
│ │ │ │ │ "292": [0, 10],
│ │ │ │ │ "294": [0, 10],
│ │ │ │ │ "296": [0, 10],
│ │ │ │ │ "2f": [3, 4, 6, 7],
│ │ │ │ │ "2gb": 6,
│ │ │ │ │ - "3": [1, 8, 9, 12, 13, 16, 17, 19, 21, 22, 23, 24],
│ │ │ │ │ - "30": [0, 6, 10],
│ │ │ │ │ + "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],
│ │ │ │ │ - "335": [6, 7],
│ │ │ │ │ + "34": 6,
│ │ │ │ │ "351": [0, 10],
│ │ │ │ │ + "353": 6,
│ │ │ │ │ "354": [0, 10],
│ │ │ │ │ - "363": 9,
│ │ │ │ │ "37": [12, 22],
│ │ │ │ │ "382": [0, 10],
│ │ │ │ │ "384": [0, 10],
│ │ │ │ │ + "389": 7,
│ │ │ │ │ "3f": 9,
│ │ │ │ │ "3rd": [0, 10],
│ │ │ │ │ - "4": [1, 4, 7, 8, 9, 12, 16, 17, 19, 21, 22, 24],
│ │ │ │ │ + "4": [1, 4, 8, 9, 12, 16, 17, 19, 21, 22, 24],
│ │ │ │ │ "40": 21,
│ │ │ │ │ "406": [0, 10],
│ │ │ │ │ - "407": 8,
│ │ │ │ │ + "40gb": 6,
│ │ │ │ │ "419": [12, 22],
│ │ │ │ │ "42": [3, 4, 8, 9, 22],
│ │ │ │ │ "420": [12, 22],
│ │ │ │ │ "421": [12, 22],
│ │ │ │ │ "422": [12, 22],
│ │ │ │ │ "423": [12, 22],
│ │ │ │ │ "424": [12, 22],
│ │ │ │ │ "425": [12, 22],
│ │ │ │ │ "426": [9, 12, 22],
│ │ │ │ │ "427": [12, 22],
│ │ │ │ │ "428": [12, 22],
│ │ │ │ │ - "42gb": 6,
│ │ │ │ │ - "43": 4,
│ │ │ │ │ "451": [0, 10],
│ │ │ │ │ "453": 24,
│ │ │ │ │ "46": [12, 22],
│ │ │ │ │ "462": 24,
│ │ │ │ │ "46947439": 3,
│ │ │ │ │ "483": [0, 10],
│ │ │ │ │ + "485": 6,
│ │ │ │ │ "490": [0, 10],
│ │ │ │ │ "49671415": 3,
│ │ │ │ │ - "49908126": 7,
│ │ │ │ │ - "49927974": 7,
│ │ │ │ │ - "49931744": 7,
│ │ │ │ │ - "49932031": 7,
│ │ │ │ │ - "49937467": 7,
│ │ │ │ │ - "49942702": 7,
│ │ │ │ │ - "49947763": 7,
│ │ │ │ │ - "49948344": 7,
│ │ │ │ │ - "49949566": 7,
│ │ │ │ │ - "49952633": 7,
│ │ │ │ │ - "49955131": 7,
│ │ │ │ │ - "49955731": 7,
│ │ │ │ │ - "4995852": 7,
│ │ │ │ │ - "49959321": 7,
│ │ │ │ │ - "49960139": 7,
│ │ │ │ │ - "49966756": 7,
│ │ │ │ │ - "49967214": 7,
│ │ │ │ │ - "49967835": 7,
│ │ │ │ │ - "49970628": 7,
│ │ │ │ │ - "49971064": 7,
│ │ │ │ │ - "49973486": 7,
│ │ │ │ │ - "4997366": 7,
│ │ │ │ │ - "49976194": 7,
│ │ │ │ │ - "49976548": 7,
│ │ │ │ │ - "49976686": 7,
│ │ │ │ │ - "49977811": 7,
│ │ │ │ │ - "4997858": 7,
│ │ │ │ │ - "49980347": 7,
│ │ │ │ │ - "49980902": 7,
│ │ │ │ │ - "49982581": 7,
│ │ │ │ │ - "49982657": 7,
│ │ │ │ │ - "49983018": 7,
│ │ │ │ │ - "49983616": 7,
│ │ │ │ │ - "49984693": 7,
│ │ │ │ │ - "49985226": 7,
│ │ │ │ │ - "49986384": 7,
│ │ │ │ │ - "49986393": 7,
│ │ │ │ │ - "49988015": 7,
│ │ │ │ │ - "4998841": 7,
│ │ │ │ │ - "49988748": 7,
│ │ │ │ │ - "49989946": 7,
│ │ │ │ │ - "49991124": 7,
│ │ │ │ │ - "49991273": 7,
│ │ │ │ │ - "49994573": 7,
│ │ │ │ │ - "49995341": 7,
│ │ │ │ │ - "49997197": 7,
│ │ │ │ │ - "49997704": 7,
│ │ │ │ │ + "49865546": 7,
│ │ │ │ │ + "49885528": 7,
│ │ │ │ │ + "49904149": 7,
│ │ │ │ │ + "49906411": 7,
│ │ │ │ │ + "49907251": 7,
│ │ │ │ │ + "49920768": 7,
│ │ │ │ │ + "4992151": 7,
│ │ │ │ │ + "49923245": 7,
│ │ │ │ │ + "49924509": 7,
│ │ │ │ │ + "49925254": 7,
│ │ │ │ │ + "4992846": 7,
│ │ │ │ │ + "49930827": 7,
│ │ │ │ │ + "4993102": 7,
│ │ │ │ │ + "49933691": 7,
│ │ │ │ │ + "49935984": 7,
│ │ │ │ │ + "49937063": 7,
│ │ │ │ │ + "49946124": 7,
│ │ │ │ │ + "49947721": 7,
│ │ │ │ │ + "4995025": 7,
│ │ │ │ │ + "49951036": 7,
│ │ │ │ │ + "49952333": 7,
│ │ │ │ │ + "49953333": 7,
│ │ │ │ │ + "49957269": 7,
│ │ │ │ │ + "49964931": 7,
│ │ │ │ │ + "49966002": 7,
│ │ │ │ │ + "49967689": 7,
│ │ │ │ │ + "49971073": 7,
│ │ │ │ │ + "49972443": 7,
│ │ │ │ │ + "49972526": 7,
│ │ │ │ │ + "49975994": 7,
│ │ │ │ │ + "49977067": 7,
│ │ │ │ │ + "49978763": 7,
│ │ │ │ │ + "49979383": 7,
│ │ │ │ │ + "49979703": 7,
│ │ │ │ │ + "4997981": 7,
│ │ │ │ │ + "49981844": 7,
│ │ │ │ │ + "49982452": 7,
│ │ │ │ │ + "49984616": 7,
│ │ │ │ │ + "49986162": 7,
│ │ │ │ │ + "49991988": 7,
│ │ │ │ │ + "4999394": 7,
│ │ │ │ │ + "49994382": 7,
│ │ │ │ │ + "49996749": 7,
│ │ │ │ │ + "49997401": 7,
│ │ │ │ │ "5": [3, 6, 8, 12, 16, 17, 19, 21, 22, 23, 24],
│ │ │ │ │ "50": [12, 17, 22],
│ │ │ │ │ - "50000409": 7,
│ │ │ │ │ - "50001355": 7,
│ │ │ │ │ - "50001362": 7,
│ │ │ │ │ - "50002963": 7,
│ │ │ │ │ - "50003417": 7,
│ │ │ │ │ - "50003621": 7,
│ │ │ │ │ - "50004606": 7,
│ │ │ │ │ - "500073": 7,
│ │ │ │ │ - "50009461": 7,
│ │ │ │ │ - "50010194": 7,
│ │ │ │ │ - "50010509": 7,
│ │ │ │ │ - "50011647": 7,
│ │ │ │ │ - "50012712": 7,
│ │ │ │ │ - "50013202": 7,
│ │ │ │ │ - "50013579": 7,
│ │ │ │ │ - "50013786": 7,
│ │ │ │ │ - "50016722": 7,
│ │ │ │ │ - "50018219": 7,
│ │ │ │ │ - "50020776": 7,
│ │ │ │ │ - "50020858": 7,
│ │ │ │ │ - "50021111": 7,
│ │ │ │ │ - "50022324": 7,
│ │ │ │ │ - "50023201": 7,
│ │ │ │ │ - "50023952": 7,
│ │ │ │ │ - "50023991": 7,
│ │ │ │ │ - "50032194": 7,
│ │ │ │ │ - "50032566": 7,
│ │ │ │ │ - "50034893": 7,
│ │ │ │ │ - "50035156": 7,
│ │ │ │ │ - "50035467": 7,
│ │ │ │ │ - "50036362": 7,
│ │ │ │ │ - "50037031": 7,
│ │ │ │ │ - "50038899": 7,
│ │ │ │ │ - "50039103": 7,
│ │ │ │ │ - "50040682": 7,
│ │ │ │ │ - "50041353": 7,
│ │ │ │ │ - "50041366": 7,
│ │ │ │ │ - "50041905": 7,
│ │ │ │ │ - "50043676": 7,
│ │ │ │ │ - "5004464": 7,
│ │ │ │ │ - "50046139": 7,
│ │ │ │ │ - "50046984": 7,
│ │ │ │ │ - "50052522": 7,
│ │ │ │ │ - "50052783": 7,
│ │ │ │ │ - "50054301": 7,
│ │ │ │ │ - "50055207": 7,
│ │ │ │ │ - "50055501": 7,
│ │ │ │ │ - "5007307": 7,
│ │ │ │ │ - "522": 4,
│ │ │ │ │ + "50001192": 7,
│ │ │ │ │ + "50002205": 7,
│ │ │ │ │ + "50003744": 7,
│ │ │ │ │ + "50009855": 7,
│ │ │ │ │ + "5001114": 7,
│ │ │ │ │ + "50012584": 7,
│ │ │ │ │ + "50012674": 7,
│ │ │ │ │ + "50014606": 7,
│ │ │ │ │ + "50015157": 7,
│ │ │ │ │ + "50015622": 7,
│ │ │ │ │ + "50015811": 7,
│ │ │ │ │ + "50016187": 7,
│ │ │ │ │ + "5001625": 7,
│ │ │ │ │ + "50016773": 7,
│ │ │ │ │ + "50017199": 7,
│ │ │ │ │ + "50020532": 7,
│ │ │ │ │ + "50021465": 7,
│ │ │ │ │ + "50021516": 7,
│ │ │ │ │ + "50021544": 7,
│ │ │ │ │ + "50021549": 7,
│ │ │ │ │ + "50022806": 7,
│ │ │ │ │ + "50023936": 7,
│ │ │ │ │ + "50025128": 7,
│ │ │ │ │ + "50025688": 7,
│ │ │ │ │ + "50030163": 7,
│ │ │ │ │ + "50030671": 7,
│ │ │ │ │ + "50030899": 7,
│ │ │ │ │ + "50034574": 7,
│ │ │ │ │ + "50035458": 7,
│ │ │ │ │ + "50036392": 7,
│ │ │ │ │ + "50036696": 7,
│ │ │ │ │ + "5003727": 7,
│ │ │ │ │ + "50037977": 7,
│ │ │ │ │ + "50040871": 7,
│ │ │ │ │ + "5004472": 7,
│ │ │ │ │ + "50047903": 7,
│ │ │ │ │ + "50049967": 7,
│ │ │ │ │ + "50055758": 7,
│ │ │ │ │ + "50057558": 7,
│ │ │ │ │ + "50065175": 7,
│ │ │ │ │ + "50066993": 7,
│ │ │ │ │ + "50068896": 7,
│ │ │ │ │ + "50070401": 7,
│ │ │ │ │ + "50071049": 7,
│ │ │ │ │ + "50073542": 7,
│ │ │ │ │ + "50074385": 7,
│ │ │ │ │ + "50078551": 7,
│ │ │ │ │ + "50085892": 7,
│ │ │ │ │ + "50086629": 7,
│ │ │ │ │ + "50088083": 7,
│ │ │ │ │ "52201": 21,
│ │ │ │ │ "52302986": 3,
│ │ │ │ │ + "53": 7,
│ │ │ │ │ "54256004": 3,
│ │ │ │ │ "55": [0, 10],
│ │ │ │ │ - "57": 7,
│ │ │ │ │ "574": 24,
│ │ │ │ │ "57921282": 3,
│ │ │ │ │ "596": 22,
│ │ │ │ │ "5e5": 7,
│ │ │ │ │ "6": [1, 8, 12, 19, 22, 24],
│ │ │ │ │ "60": 6,
│ │ │ │ │ + "630": 9,
│ │ │ │ │ "64": [0, 10],
│ │ │ │ │ "643": [0, 10],
│ │ │ │ │ "64768854": 3,
│ │ │ │ │ "7": [8, 12, 19, 20, 21, 22, 24],
│ │ │ │ │ "715": [0, 10],
│ │ │ │ │ "716": [0, 10],
│ │ │ │ │ "72": [0, 10],
│ │ │ │ │ @@ -1054,47 +1054,47 @@
│ │ │ │ │ "722": [0, 10],
│ │ │ │ │ "723": [0, 10],
│ │ │ │ │ "732": [0, 10],
│ │ │ │ │ "745": 9,
│ │ │ │ │ "746": [0, 10],
│ │ │ │ │ "747": [0, 10],
│ │ │ │ │ "751": [0, 10],
│ │ │ │ │ + "76": 7,
│ │ │ │ │ "763": 9,
│ │ │ │ │ "76743473": 3,
│ │ │ │ │ "77": 21,
│ │ │ │ │ "784": [0, 10],
│ │ │ │ │ + "79": 6,
│ │ │ │ │ "792": [0, 10],
│ │ │ │ │ "8": [1, 4, 8, 12, 19, 21, 22, 24],
│ │ │ │ │ "8000000": [22, 23],
│ │ │ │ │ "820": [0, 10],
│ │ │ │ │ "833": [0, 10],
│ │ │ │ │ "836": [0, 10],
│ │ │ │ │ "847": [0, 10],
│ │ │ │ │ "858": 24,
│ │ │ │ │ "878": [0, 10],
│ │ │ │ │ "879": [0, 10],
│ │ │ │ │ "886": 24,
│ │ │ │ │ "893": [0, 10],
│ │ │ │ │ "894": [0, 10],
│ │ │ │ │ "899": [0, 10],
│ │ │ │ │ - "89mb": 6,
│ │ │ │ │ "9": [8, 11, 12, 13, 19, 21, 22, 24],
│ │ │ │ │ "903": [0, 10],
│ │ │ │ │ "914": [0, 10],
│ │ │ │ │ "920": [0, 10],
│ │ │ │ │ - "92mb": 6,
│ │ │ │ │ "934": [0, 10],
│ │ │ │ │ "940": [0, 10],
│ │ │ │ │ - "946": 9,
│ │ │ │ │ "951": [0, 10],
│ │ │ │ │ - "96": 7,
│ │ │ │ │ + "96": 6,
│ │ │ │ │ "965": [0, 10],
│ │ │ │ │ "966": [0, 10],
│ │ │ │ │ "968": [0, 10],
│ │ │ │ │ "985": [0, 10],
│ │ │ │ │ + "99mb": 6,
│ │ │ │ │ "A": [0, 3, 8, 9, 10, 11, 12, 19, 22, 23],
│ │ │ │ │ "As": [0, 3, 8, 10, 15, 19, 21, 22, 23, 24],
│ │ │ │ │ "At": 3,
│ │ │ │ │ "Be": 3,
│ │ │ │ │ "But": [6, 21],
│ │ │ │ │ "By": [4, 11, 16, 17, 21, 22, 23, 24],
│ │ │ │ │ "For": [0, 8, 9, 10, 12, 17, 20, 21, 22, 23],