Kører i Parallel Python for Data Science - dummies

De fleste computere i dag er multicore (to eller flere processorer i en enkelt pakke), nogle med flere fysiske CPU'er. En af Pythons vigtigste begrænsninger er, at den som standard bruger en enkelt kerne. (Det blev skabt i en tid, hvor enkeltkerner var normen.)

Datavidenskabsprojekter kræver ganske mange beregninger. Navnlig er en del af det videnskabelige aspekt af datalogi afhængig af gentagne tests og eksperimenter på forskellige datamatricer. Glem ikke at arbejde med enorme datamængder betyder, at de fleste tidskrævende transformationer gentager observation efter observation (for eksempel identiske og ikke-relaterede operationer på forskellige dele af en matrix).

Ved hjælp af flere CPU-kerner accelereres en beregning med en faktor, der næsten matcher antallet af kerner. For eksempel ville have fire kerner betyde at arbejde i bedste fald fire gange hurtigere. Du modtager ikke en fuld firefoldig forøgelse, fordi der er overhead, når du starter en parallel proces - nye løbende Python-forekomster skal konfigureres med de rigtige informationer i hukommelsen og lanceres; Derfor vil forbedringen være mindre end potentielt opnåelig, men stadig signifikant.

At vide, hvordan du bruger mere end en CPU, er derfor en avanceret, men utrolig nyttig færdighed til at øge antallet af analyser, der er gennemført, og for at fremskynde dine operationer, både når du konfigurerer og bruger dine dataprodukter.

Multiprocessing værker ved at kopiere samme kode og hukommelsesindhold i forskellige nye Python-tilfælde (arbejderne), beregne resultatet for hver af dem og returnere de samlede resultater til den oprindelige konsol. Hvis din originale instans allerede optager meget af den ledige RAM-hukommelse, er det ikke muligt at oprette nye forekomster, og din maskine er muligvis tom for hukommelsen.

Udførelse af multicore-parallelisme

For at udføre multicore-parallelisme med Python integrerer du Scikit-learn-pakken med joblib-pakken til tidskrævende operationer, f.eks. Replikering af modeller til validering af resultater eller søgning efter de bedste hyperparametre. Specielt giver Scikit-learning mulighed for multiprocessing, når

• Cross-validering: Tester resultaterne af en maskinlæringshypotese ved hjælp af forskellige trænings- og testdata

• Gittersøgning: Systematisk ændring af hyperparametrene af en maskinlæringshypotese og afprøvning af de resulterende resultater

• Multilabel-forudsigelse: Kørsel af en algoritme flere gange mod flere mål, når der er mange forskellige målresultater til at forudsige på samme tid

• Ensemble-maskinlæringsmetoder: Modellering af en stor række klassifikatorer, hver uafhængig af den anden, f.eks. Ved brug af RandomForest-baseret modellering

Du behøver ikke gøre noget særligt for at udnytte parallelle beregninger - du kan aktivere parallelisme ved at indstille n_jobs -parameteren til et antal kerner mere end 1 eller ved at indstille værdien til -1, hvilket betyder at du vil bruge alle tilgængelige CPU-forekomster.

Hvis du ikke kører din kode fra konsollen eller fra en IPython Notebook, er det yderst vigtigt, at du adskiller din kode fra enhver pakkeimport eller global variabel tildeling i dit script ved hjælp af hvis __name __ == '__ main__': kommando i begyndelsen af ​​en kode, der udfører multicore parallelisme. If-erklæringen kontrollerer, om programmet køres direkte eller kaldes af en allerede igangværende Python-konsol, idet der undgås forvirring eller fejl ved multiparallelprocessen (såsom rekursivt kalder parallellen).

Demonstrere multiprocessing

Det er en god idé at bruge IPython, når du kører en demonstration af, hvordan multiprocessing virkelig kan spare dig tid i datavidenskabsprojekter. Brug af IPython giver fordelen ved at bruge kommandoen% timeit magic til timing execution. Du starter ved at indlæse et multiclass datasæt, en kompleks maskinlæringsalgoritme (Support Vector Classifier eller SVC) og en krydsvalideringsprocedure for at estimere pålidelige resultatresultater fra alle procedurer.

Det vigtigste er at procedurerne bliver ganske store, fordi SVC producerer 10 modeller, som gentager 10 gange hver med krydsvalidering til i alt 100 modeller.

fra sklearn. datasæt import load_digits cifre = load_digits () X, y = cifre. data, cifre. mål fra sklearn. svm import SVC fra Sklearn. cross_valation import cross_val_score% timeit single_core_learning = cross_val_score (SVC (), X, y, cv = 20, n_jobs = 1) Ud [1]: 1 sløjfer, bedst 3: 17. 9 s pr. sløjfe

Efter denne test, du skal aktivere multicore-parallelismen og klare resultaterne ved hjælp af følgende kommandoer:

% timeit multi_core_learning = cross_val_score (SVC (), X, y, cv = 20, n_jobs = -1) Ud [2]: 1 sløjfer, bedste af 3: 11. 7 s per loop

Eksemplermaskinen viser en positiv fordel ved brug af multicore-behandling, på trods af at du bruger et lille datasæt, hvor Python tilbringer det meste af tiden og starter en del af koden i hver enkelt. Denne overhead, et par sekunder, er stadig signifikant, da den samlede eksekvering strækker sig over en håndfuld sekunder. Forestil dig, hvad der ville ske, hvis du arbejdede med større datasæt - din eksekveringstid kunne nemt klippes med to eller tre gange.

Selv om koden fungerer fint med IPython, sætter den ned i et script og beder Python om at køre det i en konsol eller ved hjælp af en IDE, kan det medføre fejl på grund af de interne operationer af en multicore-opgave. Løsningen er at sætte hele koden under en if-erklæring, som kontrollerer om programmet startede direkte og ikke blev kaldt bagefter. Her er et eksempel script:

fra sklearn. datasæt importerer load_digits fra sklearn. svm import SVC fra Sklearn. cross_validation import cross_val_score hvis __name__ == '__main__': cifre = load_digits () X, y = cifre. data, cifre. mål multi_core_learning = cross_val_score (SVC (), X, y, cv = 20, n_jobs = -1)