S'exécutant en Parallel Python for Data Science - les nuls

La plupart des ordinateurs sont multicœurs (deux processeurs ou plus dans un seul paquet), certains avec plusieurs processeurs physiques. L'une des limitations les plus importantes de Python est qu'il utilise un seul noyau par défaut. (Il a été créé à une époque où les cœurs simples étaient la norme.)

Les projets de science des données exigent beaucoup de calculs. En particulier, une partie de l'aspect scientifique de la science des données repose sur des tests répétés et des expériences sur différentes matrices de données. N'oubliez pas que le fait de travailler avec d'énormes quantités de données signifie que la plupart des transformations fastidieuses répètent l'observation après l'observation (par exemple, des opérations identiques et non liées sur différentes parties d'une matrice).

L'utilisation de plusieurs cœurs de processeur accélère le calcul d'un facteur proche du nombre de cœurs. Par exemple, avoir quatre cœurs signifierait travailler au mieux quatre fois plus vite. Vous ne recevez pas une augmentation quadruple complète car il y a un surcoût lors du démarrage d'un processus parallèle - les nouvelles instances Python en cours d'exécution doivent être configurées avec les bonnes informations en mémoire et lancées; par conséquent, l'amélioration sera moins que potentiellement réalisable mais toujours significative.

Savoir utiliser plus d'un processeur est donc une compétence avancée mais incroyablement utile pour augmenter le nombre d'analyses effectuées et accélérer vos opérations lors de la configuration et de l'utilisation de vos produits de données.

Le multitraitement fonctionne en répliquant le même code et le même contenu mémoire dans diverses nouvelles instances Python (les travailleurs), en calculant le résultat pour chacun d'entre eux et en renvoyant les résultats regroupés à la console d'origine principale. Si votre instance d'origine occupe déjà une grande partie de la mémoire RAM disponible, il ne sera pas possible de créer de nouvelles instances et votre machine pourrait manquer de mémoire.

Exécution d'un parallélisme multicœur

Pour effectuer un parallélisme multicœur avec Python, vous intégrez le package Scikit-learn au package joblib pour les opérations fastidieuses, telles que la réplication de modèles pour la validation de résultats ou la recherche de les meilleurs hyper-paramètres. En particulier, Scikit-learn permet le multitraitement lorsque

• Cross-validation: Test des résultats d'une hypothèse d'apprentissage automatique en utilisant différentes données d'entraînement et de test

• Grid-search: Changement systématique des hyper-paramètres d'une hypothèse d'apprentissage machine et de tester les résultats conséquents

• Prédiction multi-étiquettes: Exécuter un algorithme plusieurs fois contre des cibles multiples lorsqu'il existe de nombreux résultats cibles différents à prévoir en même temps

• Modélisation d'un grand nombre de classificateurs, indépendants l'un de l'autre, comme lors de l'utilisation de la modélisation basée sur RandomForest

Vous n'avez rien de spécial à faire pour tirer parti des calculs parallèles - vous pouvez activer le parallélisme le n_jobs -paramètre à un nombre de cœurs supérieur à 1 ou en définissant la valeur à -1, ce qui signifie que vous voulez utiliser toutes les instances de CPU disponibles.

Si vous n'exécutez pas votre code depuis la console ou depuis un IPython Notebook, il est extrêmement important de séparer votre code de toute importation de paquet ou de toute affectation de variable globale dans votre script en utilisant if __name __ == '__ main__': commande au début de tout code qui exécute le parallélisme multicœur. L'instruction if vérifie si le programme est directement exécuté ou est appelé par une console Python déjà en cours, en évitant toute confusion ou erreur du processus multiparallèle (comme l'appel récursif du parallélisme).

Démonstration du multitraitement

C'est une bonne idée d'utiliser IPython lorsque vous faites une démonstration de la façon dont le multitraitement peut vraiment vous faire gagner du temps lors de projets de science des données. L'utilisation d'IPython offre l'avantage d'utiliser la commande% timeit magic pour l'exécution de la temporisation. Vous commencez par charger un ensemble de données multiclasses, un algorithme d'apprentissage automatique complexe (le classificateur de vecteur de support, ou SVC), et une procédure de validation croisée pour estimer les scores résultants fiables de toutes les procédures.

La chose la plus importante à savoir est que les procédures deviennent assez importantes parce que le SVC produit 10 modèles, qu'il répète 10 fois chacun en utilisant la validation croisée, pour un total de 100 modèles.

de sklearn. jeux de données import load_digits chiffres = load_digits () X, y = chiffres. données, chiffres. cible de Sklearn. SVM importer SVC de sklearn. cross_validation import cross_val_score% temps single_core_learning = cross_val_score (SVC (), X, y, cv = 20, n_jobs = 1) Out [1]: 1 boucles, meilleur de 3: 17. 9 s par boucle

Après ce test, vous devez activer le parallélisme multicœur et chronométrer les résultats en utilisant les commandes suivantes:

% timeit multi_core_learning = cross_val_score (SVC (), X, y, cv = 20, n_jobs = -1) Out [2]: 1 boucles, meilleur de 3: 11. 7 s par boucle

L'exemple de machine démontre un avantage positif en utilisant le traitement multicœur, malgré l'utilisation d'un petit ensemble de données où Python passe la plupart du temps à démarrer des consoles et à exécuter une partie du code dans chacune. Cette surcharge, de quelques secondes, est toujours significative étant donné que l'exécution totale s'étend sur quelques secondes. Imaginez ce qui se passerait si vous utilisiez des ensembles de données plus volumineux - votre temps d'exécution pourrait être facilement réduit de deux ou trois fois.

Bien que le code fonctionne bien avec IPython, le mettre dans un script et demander à Python de l'exécuter dans une console ou d'utiliser un IDE peut provoquer des erreurs à cause des opérations internes d'une tâche multicœur. La solution consiste à placer tout le code sous une instruction if, qui vérifie si le programme a démarré directement et n'a pas été appelé par la suite. Voici un exemple de script:

de sklearn. les datasets importent load_digits de sklearn. SVM importer SVC de sklearn. cross_validation import cross_val_score if __name__ == '__main__': chiffres = load_digits () X, y = chiffres. données, chiffres. target multi_core_learning = cross_val_score (SVC (), X, y, cv = 20, n_jobs = -1)