Tabla de contenidos

 
Introducción
 Ejemplo 1: suma acumulada
Secuencial
multiprocessing Pool.map
joblib
 Ejemplo 2: entrenamiento de modelos
Secuencial
multiprocessing Pool.map Paralelizar bucle for
con Python
joblib
Información de sesión

Joaquín Amat Rodrigo

Noviembre, 2020

Más sobre ciencia de datos en cienciadedatos.net

(https://cienciadedatos.net)

Introducción

Este documento contiene ejemplos de cómo paralelizar bucles for con

python. En concreto, se muestra cómo utilizar las funcionalidades de
paralelizado que ofrecen las librerías multiprocessing y joblib .

Para las dos librerías, se muestra cómo paralelizar una función sencilla
y cómo paralelizar el entrenamiento de modelos de scikit-learn
(https://www.cienciadedatos.net/documentos
/py06_machine_learning_python_scikitlearn.html).

Ejemplo 1: suma
acumulada

Secuencial
In [1]: # secuencial (no paralelizado)
# ====================================================
==========================
import pandas as pd
import numpy as np

# Se define la función
def suma_acumulada(number):
return sum(range(1, number + 1))

# Lista de elementos sobre los que se quiere aplicar l

a función
valores = [10**8, 10**8, 10**8, 10**8, 10**8]
Tabla de contenidos In [2]: %%time
 
# Aplicar la función sobre cada elemento de forma secu
Introducción
encial
 Ejemplo 1: suma acumulada
resultados = []
Secuencial
multiprocessing Pool.map for valor in valores:
joblib resultado = suma_acumulada(valor)
 Ejemplo 2: entrenamiento de modelos resultados.append(resultado)
Secuencial
multiprocessing Pool.map resultados
joblib
Información de sesión CPU times: user 9.28 s, sys: 32.2 ms, total: 9.31 s
Wall time: 9.26 s

Out[2]: [5000000050000000,
5000000050000000,
5000000050000000,
5000000050000000,
5000000050000000]

multiprocessing Pool.map
In [3]: # multiprocessing Pool.map
# ====================================================
==========================
import pandas as pd
import numpy as np
import multiprocessing

# Se define la función
def suma_acumulada(number):
return sum(range(1, number + 1))

# Lista de elementos sobre los que se quiere aplicar l

a función
valores = [10**8, 10**8, 10**8, 10**8, 10**8]

In [4]: %%time

# Aplicar la función sobre cada elemento en paralelo

pool = multiprocessing.Pool(processes=multiprocessing.
cpu_count())
resultados = pool.map(suma_acumulada, valores)
resultados

CPU times: user 5.92 ms, sys: 28.1 ms, total: 34 ms

Wall time: 3 s

Out[4]: [5000000050000000,
5000000050000000,
5000000050000000,
5000000050000000,
5000000050000000]

joblib
In [5]: # joblib
# ====================================================
==========================
import pandas as pd
import numpy as np
import multiprocessing
from joblib import Parallel, delayed

# Se define la función
def suma_acumulada(number):
return sum(range(1, number + 1))

# Lista de elementos sobre los que se quiere aplicar l

a función
valores = [10**8, 10**8, 10**8, 10**8, 10**8]
Tabla de contenidos In [6]: %%time
 
# Aplicar la función sobre cada elemento en paralelo
Introducción
n_jobs = multiprocessing.cpu_count()
 Ejemplo 1: suma acumulada
Parallel(n_jobs=n_jobs)(delayed(suma_acumulada)(i) for
Secuencial
i in valores)
multiprocessing Pool.map
joblib CPU times: user 29.4 ms, sys: 43.3 ms, total: 72.7 ms
 Ejemplo 2: entrenamiento de modelos Wall time: 3.13 s
Secuencial
Out[6]: [5000000050000000,
multiprocessing Pool.map
5000000050000000,
joblib
5000000050000000,
Información de sesión
5000000050000000,
5000000050000000]

Ejemplo 2: entrenamiento de
modelos

Secuencial
In [7]: # Secuencial (no paralelizado)
# ====================================================
==========================
import pandas as pd
import numpy as np
from sklearn.datasets import load_boston
from sklearn.ensemble import RandomForestRegressor

# Datos de entrenamiento
X, y = load_boston(return_X_y=True)

# Valores sobre los que iterar en paralelo

list_n_estimators = [1000, 2000, 5000, 10000]

# Función de entrenamiento
def train_model(X, y, n_estimators):

model = RandomForestRegressor(
n_estimators = n_estimators,
n_jobs = 1,
random_state = 123
)

model.fit(X, y)

return model

In [8]: %%time
modelos = []

for n_estimators in list_n_estimators:

modelo = train_model(X, y, n_estimators)
modelos.append(modelo)

CPU times: user 55.8 s, sys: 488 ms, total: 56.3 s

Wall time: 56.3 s

multiprocessing Pool.map
Tabla de contenidos In [9]: # Entrenamiento paralelo de múltiples modelos multipro
cessing Pool.map()
 
# ====================================================
Introducción
==========================
 Ejemplo 1: suma acumulada
Secuencial
import pandas as pd
multiprocessing Pool.map import numpy as np
joblib import multiprocessing
 Ejemplo 2: entrenamiento de modelos from sklearn.datasets import load_boston
Secuencial from sklearn.ensemble import RandomForestRegressor
multiprocessing Pool.map
joblib # Datos de entrenamiento
Información de sesión X, y = load_boston(return_X_y=True)

# Valores sobre los que iterar en paralelo

list_n_estimators = [1000, 2000, 5000, 10000]

# Función de entrenamiento
def train_model(X, y, n_estimators):

model = RandomForestRegressor(
n_estimators = n_estimators,
n_jobs = 1,
random_state = 123
)

model.fit(X, y)

return model

In [10]: %%time

n_jobs = multiprocessing.cpu_count()
pool = multiprocessing.Pool(processes=multiprocessi
ng.cpu_count())
modelos = pool.starmap(train_model, [(X, y, n_estimato
rs) for n_estimators in list_n_estimators])

CPU times: user 1.15 s, sys: 1.55 s, total: 2.7 s

Wall time: 33.7 s

joblib
In [11]: # Entrenamiento paralelo de múltiples modelos joblib
# ====================================================
==========================

import pandas as pd
import numpy as np
from joblib import Parallel, delayed
from sklearn.datasets import load_boston
from sklearn.ensemble import RandomForestRegressor

# Datos de entrenamiento
X, y = load_boston(return_X_y=True)

# Valores sobre los que iterar en paralelo

list_n_estimators = [1000, 2000, 5000, 10000]

# Función de entrenamiento
def train_model(X, y, n_estimators):

model = RandomForestRegressor(
n_estimators = n_estimators,
n_jobs = 1,
random_state = 123
)

model.fit(X, y)

return model
Tabla de contenidos In [12]: %%time
 
n_jobs = multiprocessing.cpu_count()
Introducción
modelos = Parallel(n_jobs=n_jobs)(delayed(train_mode
 Ejemplo 1: suma acumulada
l)(X, y, n_estimators) for n_estimators in list_n_esti
Secuencial
mators)
multiprocessing Pool.map
joblib CPU times: user 1.65 s, sys: 1.64 s, total: 3.3 s
 Ejemplo 2: entrenamiento de modelos Wall time: 35.9 s
Secuencial
multiprocessing Pool.map
joblib
Información de sesión
Información de sesión
In [13]: from sinfo import sinfo
sinfo()

-----
joblib 0.15.1
numpy 1.19.2
pandas 1.1.3
sinfo 0.3.1
sklearn 0.23.1
-----
IPython 7.18.1
jupyter_client 6.1.7
jupyter_core 4.6.3
jupyterlab 2.2.9
notebook 6.1.4
-----
Python 3.7.9 (default, Aug 31 2020, 12:42:55) [GCC 7.3.0]
Linux-5.4.0-1029-aws-x86_64-with-debian-buster-sid
8 logical CPU cores, x86_64
-----
Session information updated at 2020-10-31 13:07