[PYTHON] Parallele Verarbeitung mit Parallel von Scikit-Learn

Nachtrag 2019/1016: Ich habe über die Cache-Funktion von Joblib geschrieben. [[Python] Verwenden Sie den Joblib-Cache, um dieselbe Berechnung wegzulassen](https://tma15.github.io/blog/2019/10/06/python-Verwenden Sie den Joblib-Cache, um dieselbe Berechnung wegzulassen /)

Apropos Scikit-Lern-Tutorials: Die Einführung von @Scaled_Wurm Man ist sehr einfach zu verstehen. Diesmal habe ich zufällig den Quellcode gelesen und eine Nische notiert, die nicht im Blogeintrag eingeführt wurde. Die Schlussfolgerung ist, dass, wenn es keinen bestimmten Grund gibt, der in Multiprocessing geschriebene Teil durch Parallel ersetzt werden kann.

Parallel

• Klasse, die Parallelverarbeitung durchführt
• Grundsätzlich wird Multiprocessing für die Parallelverarbeitung verwendet, bietet jedoch eine Hilfefunktion, die ich mir gewünscht hätte.

Ist Multiprocessing nutzlos?

Parallel ist (Original ist Notizen im Quellcode)

• Sie müssen keine Liste von Funktionsargumenten erstellen
• Debug ist einfach
• Sie können die Parallelfunktion entfernen, indem Sie n_jobs = 1 setzen, ohne den Code zu ändern.
• Verfolgt Fehler, die von untergeordneten Prozessen ausgelöst wurden
• Sie können den Fortschritt sehen
• Sie können einen Multiprocessing-Job mit "Strg-C" problemlos abbrechen (Referenz. Schwimmbad)))

Streit

• n_jobs (int): Anzahl der parallel zu verarbeitenden CPUs
• verbose (int): Das Detail der Ausgabenachricht. Nachrichtenausgabe bei allen Iterationen mit 10 oder mehr.
• pre_dispatch: Anzahl der CPUs, die vor dem Start der Parallelverarbeitung aufgerufen wurden

Beispiel

• Das Beispiel ist schneller zu sehen
• verzögert ist ein Wrapper für die Funktion, die Sie parallel verarbeiten möchten, und gibt die Funktion und ihre Argumente zurück. Diese Funktionen werden ausgeführt, wenn Parallel call () aufgerufen wird.

Einfaches Beispiel

>>> from math import sqrt
>>> from sklearn.externals.joblib import Parallel, delayed
>>> Parallel(n_jobs=1)(delayed(sqrt)(i**2) for i in range(10))
[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]

Beispiel für den Fortschritt

>>> from time import sleep
>>> from sklearn.externals.joblib import Parallel, delayed
>>> r = Parallel(n_jobs=2, verbose=5)(delayed(sleep)(.1) for _ in range(10)) #doctest: +SKIP
[Parallel(n_jobs=2)]: Done   1 out of  10 | elapsed:    0.1s remaining:    0.9s
[Parallel(n_jobs=2)]: Done   3 out of  10 | elapsed:    0.2s remaining:    0.5s
[Parallel(n_jobs=2)]: Done   6 out of  10 | elapsed:    0.3s remaining:    0.2s
[Parallel(n_jobs=2)]: Done   9 out of  10 | elapsed:    0.5s remaining:    0.1s
[Parallel(n_jobs=2)]: Done  10 out of  10 | elapsed:    0.5s finished

• Je größer der Wert, den Sie ausführlich eingeben, desto mehr Nachrichten erhalten Sie.

>>> from math import sqrt
>>> from sklearn.externals.joblib import Parallel, delayed

>>> def producer():
...     for i in range(6):
...         print('Produced %s' % i)
...         yield i

>>> out = Parallel(n_jobs=2, verbose=100, pre_dispatch='1.5*n_jobs')(
...                         delayed(sqrt)(i) for i in producer()) #doctest: +SKIP
Produced 0 ###
Produced 1 ###Geben Sie pre_dispatch an + default is'all '+ Wenn ein Job viel Speicher belegt, scheint er durch Reduzieren verwendet zu werden. + Im folgenden Beispiel werden 3 (1,5 * 2 Jobs) aufgerufen, bevor 3 Jobs parallel verarbeitet werden 1. und 2 ..
Produced 2 ###Dritte
[Parallel(n_jobs=2)]: Done   1 jobs       | elapsed:    0.0s
Produced 3
[Parallel(n_jobs=2)]: Done   2 jobs       | elapsed:    0.0s
Produced 4
[Parallel(n_jobs=2)]: Done   3 jobs       | elapsed:    0.0s
Produced 5
[Parallel(n_jobs=2)]: Done   4 jobs       | elapsed:    0.0s
[Parallel(n_jobs=2)]: Done   5 out of   6 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=2)]: Done   6 out of   6 | elapsed:    0.0s finished