Körs i Parallel Python för Data Science - dummies

De flesta datorer idag är multicore (två eller flera processorer i ett enda paket), en del av datorerna är en del. med flera fysiska processorer. En av Pythons viktigaste begränsningar är att den använder sig av en enda kärna som standard. (Det skapades i en tid när singelkärnor var normen.)

Datavetenskapsprojekt kräver ganska mycket beräkningar. I synnerhet bygger en del av den vetenskapliga aspekten av datavetenskap på upprepade tester och experiment på olika datamatriser. Glöm inte att arbeta med enorma datamängder innebär att de flesta tidskrävande omvandlingar repeterar observation efter observation (till exempel identiska och inte relaterade operationer på olika delar av en matris).

Med mer CPU-kärnor accelererar en beräkning med en faktor som nästan matchar antalet kärnor. Till exempel skulle ha fyra kärnor betyda att arbeta i bästa fall fyra gånger snabbare. Du får inte en fullständig fyrfaldig ökning eftersom det finns överkostnader när du startar en parallellprocess - nya löpande Python-instanser måste konfigureras med rätt information i minnet och lanseras. Följaktligen kommer förbättringen att bli mindre än potentiellt uppnåelig men fortfarande betydande.

Att veta hur man använder mer än en CPU är därför en avancerad men oerhört användbar skicklighet för att öka antalet analyser som genomförts och för att påskynda din verksamhet både när du installerar och använder dina dataprodukter.

Multiprocessing fungerar genom att kopiera samma kod och minnesinnehåll i olika nya Python-instanser (arbetarna), beräkna resultatet för var och en och returnera de samlade resultaten till huvudkonsolen. Om din ursprungliga instans redan upptar mycket av det tillgängliga RAM-minnet, kommer det inte att vara möjligt att skapa nya instanser och din dator kan slutföra minne.

Utför multicore parallellitet

För att utföra multicore parallellitet med Python integrerar du paketet Scikit-learn med joblib-paketet för tidskrävande operationer, till exempel replikerande modeller för att validera resultat eller för att leta efter de bästa hyperparametrarna. I synnerhet tillåter Scikit-learning multiprocessing när

• Cross-validering: Testar resultaten av en maskinlärande hypotes med hjälp av olika tränings- och testdata

• Grid-sökning: Systematiskt byter hyperparametrar av en maskinlärande hypotes och testa följderna av resultatet

• Multilabel-förutsägelse: Köra en algoritm flera gånger mot flera mål när det finns många olika målresultat att förutse samtidigt

• Ensemble maskininlärningsmetoder: Modellering av en stor värd klassificerare, var och en oberoende av varandra, till exempel när man använder RandomForest-baserad modellering

Du behöver inte göra något speciellt för att utnyttja parallella beräkningar - du kan aktivera parallellitet genom att ställa in n_jobs -parametern till ett antal kärnor mer än 1 eller genom att ange värdet till -1, vilket innebär att du vill använda alla tillgängliga CPU-instanser.

Om du inte kör din kod från konsolen eller från en IPython Notebook är det mycket viktigt att du skiljer din kod från vilken paketimport eller global variabel uppgift som helst i ditt script genom att använda om __name __ == '__ main__': kommando i början av en kod som kör multicore parallellitet. Om-testet kontrollerar om programmet körs direkt eller kallas av en Python-konsol som redan är igång, vilket undviker förvirring eller fel vid multiparallellprocessen (som rekursivt kallar parallellen).

Demonstrera multiprocessing

Det är en bra idé att använda IPython när du kör en demonstration av hur multiprocessing verkligen kan spara dig tid under datavetenskapsprojekt. Användning av IPython ger fördelen att du använder kommandot% timeit magic för att köra timing. Du börjar med att ladda in en multiclassdataset, en komplex maskininlärningsalgoritm (Support Vector Classifier eller SVC) och en kryssvalideringsprocedur för att uppskatta pålitliga resultatresultat från alla procedurer.

Det viktigaste att veta är att förfarandena blir ganska stora, eftersom SVC producerar 10 modeller, som det upprepar 10 gånger var och en använder tvärvalidering, för totalt 100 modeller.

från sklearn. dataset importera load_digits digits = load_digits () X, y = siffror. data, siffror. målet från sklearn. svm import SVC från Sklearn. cross_validation import cross_val_score% timeit single_core_learning = cross_val_score (SVC (), X, y, cv = 20, n_jobs = 1) Ut [1]: 1 slingor, bäst av 3: 17. 9 s per slinga

Efter detta test, Du måste aktivera multicore-parallellismen och testa resultaten med följande kommandon:

% timeit multi_core_learning = cross_val_score (SVC (), X, Y, cv = 20, n_jobs = -1) Ut [2]: 1 slingor, bäst av 3: 11. 7 s per loop

Exemplet maskinen visar en positiv fördel med multicore-bearbetning trots att man använder en liten dataset där Python tillbringar större delen av tiden och startar konsoler och kör en del av koden i varje. Detta överhuvudtaget, några sekunder, är fortfarande signifikant med tanke på att det totala utförandet sträcker sig för en handfull sekunder. Tänk dig vad som skulle hända om du arbetade med större datasatser - din körtid kunde lätt klippas med två eller tre gånger.

Även om koden fungerar bra med IPython, lägger den ner i ett manus och frågar Python om att köra den i en konsol eller använda en IDE, kan det orsaka fel på grund av den interna verksamheten för en multicore-uppgift. Lösningen är att sätta hela koden under ett if-meddelande, som kontrollerar om programmet startade direkt och inte kallades efteråt. Här är ett exempel manus:

från sklearn. dataset importerar load_digits från sklearn. svm import SVC från Sklearn. cross_validation import cross_val_score om __name__ == '__main__': siffror = load_digits () X, y = siffror. data, siffror. mål multi_core_learning = cross_val_score (SVC (), X, y, cv = 20, n_jobs = -1)