La multiprocessing di Python non sembra utilizzare più di un core

Question

Desidero utilizzare la multiprocessing di Python per eseguire la ricerca della griglia per un modello predittivo. Quando guardo l'utilizzo di base, sembra che stia usando solo un core. Qualche idea su cosa sto facendo male?

import multiprocessing 
from sklearn import svm 
import itertools 

#first read some data 
#X will be my feature Numpy 2D array 
#y will be my 1D Numpy array of labels 

#define the grid   
C = [0.1, 1] 
gamma = [0.0] 
params = [C, gamma] 
grid = list(itertools.product(*params)) 
GRID_hx = [] 

def worker(par, grid_list): 
    #define a sklearn model 
    clf = svm.SVC(C=g[0], gamma=g[1],probability=True,random_state=SEED) 
    #run a cross validation function: returns error 
    ll = my_cross_validation_function(X, y, model=clf, n=1, test_size=0.2) 
    print(par, ll) 
    grid_list.append((par, ll)) 


if __name__ == '__main__': 
    manager = multiprocessing.Manager() 
    GRID_hx = manager.list() 
    jobs = [] 
    for g in grid: 
     p = multiprocessing.Process(target=worker, args=(g,GRID_hx)) 
     jobs.append(p) 
     p.start() 
     p.join() 

    print("\n-------------------") 
    print("SORTED LIST") 
    print("-------------------") 
    L = sorted(GRID_hx, key=itemgetter(1)) 
    for l in L[:5]: 
     print l 

Answer 1

Il tuo problema è che si uniscono ogni posto di lavoro subito dopo si è iniziato:

for g in grid: 
    p = multiprocessing.Process(target=worker, args=(g,GRID_hx)) 
    jobs.append(p) 
    p.start() 
    p.join() 

unirsi blocchi fino a quando il relativo processo è finito di lavorare. Ciò significa che il tuo codice inizia un solo processo alla volta, attende fino al suo completamento e quindi avvia il successivo.

Al fine di tutti i processi per l'esecuzione in parallelo, è necessario prima avviarli tutti e poi unirsi a loro tutto:

jobs = [] 
for g in grid: 
    p = multiprocessing.Process(target=worker, args=(g,GRID_hx)) 
    jobs.append(p) 
    p.start() 

for j in jobs: 
    j.join() 

Documentazione: link

Answer 2

direi:

for g in grid: 
    g.p = multiprocessing.Process(target=worker, args=(g,GRID_hx)) 
    jobs.append(g.p) 
    g.p.start() 
for g in grid: 
    g.p.join() 

Attualmente il gioco è la deposizione delle uova di un lavoro, poi waithing per essere fatta, andando poi a quello successivo.

Answer 3

Secondo the documentation il join() blocca il thread corrente fino a quando non viene restituito il thread specificato. Quindi in pratica stai iniziando ogni thread nel ciclo for e poi aspetti che finisca, PRIMA di procedere alla successiva iterazione.

Suggerirei di spostare i join all'esterno del ciclo!