Paralelizar bucle for con Python
Más sobre ciencia de datos en 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.
Ejemplo 1: suma acumulada¶
Secuencial¶
# 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 la función
valores = [10**8, 10**8, 10**8, 10**8, 10**8]
%%time
# Aplicar la función sobre cada elemento de forma secuencial
resultados = []
for valor in valores:
resultado = suma_acumulada(valor)
resultados.append(resultado)
resultados
multiprocessing Pool.map¶
# 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 la función
valores = [10**8, 10**8, 10**8, 10**8, 10**8]
%%time
# Aplicar la función sobre cada elemento en paralelo
pool = multiprocessing.Pool(processes=multiprocessing.cpu_count())
resultados = pool.map(suma_acumulada, valores)
resultados
joblib¶
# 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 la función
valores = [10**8, 10**8, 10**8, 10**8, 10**8]
%%time
# Aplicar la función sobre cada elemento en paralelo
n_jobs = multiprocessing.cpu_count()
Parallel(n_jobs=n_jobs)(delayed(suma_acumulada)(i) for i in valores)
Ejemplo 2: entrenamiento de modelos¶
Secuencial¶
# 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
%%time
modelos = []
for n_estimators in list_n_estimators:
modelo = train_model(X, y, n_estimators)
modelos.append(modelo)
multiprocessing Pool.map¶
# Entrenamiento paralelo de múltiples modelos multiprocessing Pool.map()
# ==============================================================================
import pandas as pd
import numpy as np
import multiprocessing
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
%%time
n_jobs = multiprocessing.cpu_count()
pool = multiprocessing.Pool(processes=multiprocessing.cpu_count())
modelos = pool.starmap(train_model, [(X, y, n_estimators) for n_estimators in list_n_estimators])
joblib¶
# 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
%%time
n_jobs = multiprocessing.cpu_count()
modelos = Parallel(n_jobs=n_jobs)(delayed(train_model)(X, y, n_estimators) for n_estimators in list_n_estimators)
Información de sesión¶
from sinfo import sinfo
sinfo()
¿Cómo citar este documento?
Paralelizar con Python por Joaquín Amat Rodrigo, disponible con licencia CC BY-NC-SA 4.0 en https://www.cienciadedatos.net/documentos/py12-paralelizar-con-python.html 
Este contenido, creado por Joaquín Amat Rodrigo, tiene licencia Attribution-NonCommercial-ShareAlike 4.0 International.
Se permite:
-
Compartir: copiar y redistribuir el material en cualquier medio o formato.
-
Adaptar: remezclar, transformar y crear a partir del material.
Bajo los siguientes términos:
-
Atribución: Debes otorgar el crédito adecuado, proporcionar un enlace a la licencia e indicar si se realizaron cambios. Puedes hacerlo de cualquier manera razonable, pero no de una forma que sugiera que el licenciante te respalda o respalda tu uso.
-
NoComercial: No puedes utilizar el material para fines comerciales.
-
CompartirIgual: Si remezclas, transformas o creas a partir del material, debes distribuir tus contribuciones bajo la misma licencia que el original.