Traitement parallèle avec Parallel de scikit-learn

Addendum 2019/1016: J'ai écrit sur la fonction de cache de Joblib. [[Python] Utilisez le cache de Joblib pour omettre le même calcul](https://tma15.github.io/blog/2019/10/06/python-Utilisez le cache de Joblib pour omettre le même calcul /)

En parlant de tutoriels scikit-learn, l'introduction de @Scaled_Wurm Man est très facile à comprendre. Cette fois, il m'est arrivé de lire le code source et de noter une niche qui n'a pas été introduite dans entrée de blog. La conclusion est que s'il n'y a pas de raison particulière, la partie écrite en multitraitement peut être remplacée par Parallel.

Parallel

• Classe qui effectue un traitement parallèle
• Fondamentalement, le multitraitement est utilisé pour le traitement parallèle, mais il fournit une fonction d'aide que j'aurais aimé avoir.

Le multitraitement est-il inutile?

Parallèle est (Original est Notes dans le code source)

• Vous n'avez pas besoin de créer une liste d'arguments de fonction
• le débogage est facile
• Vous pouvez éliminer la fonction parallèle en définissant n_jobs = 1 sans changer le code.
• Trace les erreurs générées par les processus enfants
• Vous pouvez voir les progrès
• Vous pouvez annuler un travail multiprocesseur avec Ctrl-C sans aucun tracas (Référence bassin)))

argument

• n_jobs (int): Nombre de cpu à traiter en parallèle
• verbeux (int): Le détail du message de sortie. Sortie de message sur toutes les itérations avec 10 ou plus.
• pre_dispatch: Nombre de cpu appelés avant de démarrer le traitement parallèle

Exemple

• C'est plus rapide de voir l'exemple
• delay est un wrapper pour la fonction que vous souhaitez exécuter en parallèle et renvoie la fonction et ses arguments. Ces fonctions sont exécutées lorsque Parallel call () est appelé.

Exemple simple

>>> 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]

Exemple de progrès

>>> 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

• Plus la valeur que vous mettez dans verbose est élevée, plus vous recevez de messages.
• Affiche le nombre de travaux, le temps écoulé, etc.

Spécifiez pre_dispatch

• la valeur par défaut est «tous»
• Si un travail utilise beaucoup de mémoire, je me demande s'il sera utilisé en le réduisant.
• Dans l'exemple ci-dessous, 3 jobs (1,5 * 2 jobs) sont appelés avant le traitement parallèle.

>>> 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 ###Le premier
Produced 1 ###Seconde
Produced 2 ###Troisième
[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