Esto es sorprendente, ¡así que tendremos que resolver cuál es el problema y asegurarnos de que funciona!

¿Puede proporcionar un poco más de detalle?

• ¿A qué te refieres con "accidentes"?
• ¿Qué versión de scikit-learn es esta? Si es 0.14, ¿todavía ocurre en la versión de desarrollo actual?
• El multiprocesamiento tiene problemas específicos de la plataforma. ¿En qué plataforma estás? (por ejemplo, import platform; platform.platform() )
• ¿Lo ha probado en diferentes conjuntos de datos?

FWIW, mi máquina no tiene problemas para ajustar iris con este fragmento en la versión de desarrollo de sklearn.

Gracias por tu respuesta rápida.

Con estrellarse me refiero a congelar. Ya no continúa y tampoco hay más actividad que monitorear en el proceso de Python del administrador de tareas de Windows. Los procesos siguen ahí y consumen una cantidad constante de RAM, pero no requieren tiempo de procesamiento.

Esta es la versión 0.14 de scikit-learn, actualizada por última vez y ejecutada con Enthought Canopy.

Estoy en la plataforma "Windows-7-6.1.7601-SP1".

Profundizaré más dando un ejemplo genérico del problema. Creo que tiene que ver con GridSearchCV colocado en un bucle for. (Para no perder demasiado tiempo, probablemente debería comenzar en el método run_tune_process () que se llama en la parte inferior del código y llama al método que contiene GridSearchCV () en un bucle for)

Código:

import sklearn.metrics as metrics
from sklearn.grid_search import GridSearchCV
import numpy as np
import os
from sklearn import datasets
from sklearn import svm as sk


def tune_hyperparameters(trainingData, period):
    allDataTrain = trainingData

    # Define hyperparameters and construct a dictionary of them
    amount_kernels = 2
    kernels = ['rbf','linear']
    gamma_range =   10. ** np.arange(-5, 5)
    C_range =       10. ** np.arange(-5, 5)
    tuned_parameters = [
                        {'kernel': ['rbf'],     'gamma': gamma_range , 'C': C_range},
                        {'kernel': ['linear'],  'C': C_range}
                       ]

    print("Tuning hyper-parameters on period = " + str(period) + "\n")

    clf = GridSearchCV( sk.SVC(), 
                        tuned_parameters,
                        cv=5,
                        pre_dispatch='4*n_jobs', 
                        n_jobs=2,
                        verbose = 1,
                        scoring=metrics.make_scorer(metrics.scorer.f1_score, average="macro")
                        )
    clf.fit(allDataTrain[:,1:], allDataTrain[:,0:1].ravel())

    # other code will output some data to files, graphs and will save the optimal model with joblib package


    #   Eventually we will return the optimal model
    return clf

def run_tune_process(hyperparam_tuning_method,trainingData, testData):    
    for period in np.arange(0,100,10):
                clf = hyperparam_tuning_method(trainingData,period)

                y_real = testData[:,0:1].ravel()
                y_pred = clf.predict(testData[:,1:])

# import some data to play with
iris = datasets.load_iris()
X_training = iris.data[0:100,:]  
Y_training = (iris.target[0:100]).reshape(100,1)
trainingset = np.hstack((Y_training, X_training))

X_test = iris.data[100:150,:]  
Y_test = (iris.target[100:150]).reshape(50,1)
testset = np.hstack((Y_test, X_test))

run_tune_process(tune_hyperparameters,trainingset,testset)

Una vez más, este código funciona en mi computadora solo cuando cambio n_jobs a 1 o cuando no defino un argumento scoring =.

Generalmente, el multiprocesamiento en Windows encuentra muchos problemas. Pero yo
No sé por qué esto debería correlacionarse con una métrica personalizada. Hay
nada sobre la opción average = macro en 0.14 que sugiera que debería ser
es más probable que se cuelgue que el promedio predeterminado (ponderado). En el desarrollo
head, esto se completa en 11 segundos en mi macbook y en 7 segundos en la versión 0.14
(¡eso es algo para investigar!)

¿Puede probar esto en la versión de desarrollo actual, para ver si
sigue siendo un problema?

El 25 de febrero de 2014 a las 20:40, adverley [email protected] escribió:

Gracias por tu respuesta rápida.

Con estrellarse me refiero a congelar. Ya no continúa y
Tampoco hay más actividad que monitorear en el proceso de Python de
administrador de tareas de windows. Los procesos siguen ahí y consumen una
cantidad constante de RAM pero no requiere tiempo de procesamiento.

Esta es la versión 0.14 de scikit-learn, actualizada por última vez y ejecutada con Enthought
Pabellón.

Estoy en la plataforma "Windows-7-6.1.7601-SP1".

Profundizaré más dando un ejemplo genérico del problema. I
creo que tiene que ver con GridSearchCV colocado en un bucle for. (Para
no pierda demasiado de su tiempo, probablemente debería comenzar por el
método run_tune_process () que se llama al final del código
y llama al método que contiene GridSearchCV () en un bucle for)
Código:

importar sklearn.metrics como métricas
desde sklearn.grid_search importar GridSearchCV
importar numpy como np
importar sistema operativo
desde sklearn importar conjuntos de datos
desde sklearn importar svm como sk

def tune_hyperparameters (trainingData, período):
allDataTrain = trainingData

# Define hyperparameters and construct a dictionary of them
amount_kernels = 2
kernels = ['rbf','linear']
gamma_range =   10. ** np.arange(-5, 5)
C_range =       10. ** np.arange(-5, 5)
tuned_parameters = [
                    {'kernel': ['rbf'],     'gamma': gamma_range , 'C': C_range},
                    {'kernel': ['linear'],  'C': C_range}
                   ]

print("Tuning hyper-parameters on period = " + str(period) + "\n")

clf = GridSearchCV( sk.SVC(),
                    tuned_parameters,
                    cv=5,
                    pre_dispatch='4*n_jobs',
                    n_jobs=2,
                    verbose = 1,
                    scoring=metrics.make_scorer(metrics.scorer.f1_score, average="macro")
                    )
clf.fit(allDataTrain[:,1:], allDataTrain[:,0:1].ravel())

# other code will output some data to files, graphs and will save the optimal model with joblib package


#   Eventually we will return the optimal model
return clf

def run_tune_process (hyperparam_tuning_method, trainingData, testData):
para el período en np. rango (0,100,10):
clf = hyperparam_tuning_method (trainingData, punto)

            y_real = testData[:,0:1].ravel()
            y_pred = clf.predict(testData[:,1:])

importar algunos datos para jugar

iris = conjuntos de datos.load_iris ()
X_training = iris.data [0: 100 ,:]
Y_training = (iris.target [0: 100]). Remodelar (100,1)
trainingset = np.hstack ((Y_training, X_training))

X_test = iris.data [100: 150 ,:]
Y_test = (iris.target [100: 150]). Remodelar (50,1)
testset = np.hstack ((Y_test, X_test))

run_tune_process (tune_hyperparameters, trainingset, testset)

Responda a este correo electrónico directamente o véalo en Gi
.

(Como punto lateral, @ogrisel , noto que parece haber mucho más joblib
sobrecarga de paralelización en el maestro, al menos en OS X, que no estaba allí
en 0,14 ...)

El 25 de febrero de 2014 a las 21:52, Joel Nothman [email protected] escribió :

Generalmente, el multiprocesamiento en Windows encuentra muchos problemas. Pero yo
No sé por qué esto debería correlacionarse con una métrica personalizada. Hay
nada sobre la opción average = macro en 0.14 que sugiera que debería ser
es más probable que se cuelgue que el promedio predeterminado (ponderado). En el desarrollo
head, esto se completa en 11 segundos en mi macbook y en 7 segundos en la versión 0.14
(¡eso es algo para investigar!)

¿Puede probar esto en la versión de desarrollo actual, para ver si
sigue siendo un problema?

El 25 de febrero de 2014 a las 20:40, adverley [email protected] escribió:

Gracias por tu respuesta rápida.

Con estrellarse me refiero a congelar. Ya no continúa y
Tampoco hay más actividad que monitorear en el proceso de Python de
administrador de tareas de windows. Los procesos siguen ahí y consumen una
cantidad constante de RAM pero no requiere tiempo de procesamiento.

Esta es la versión 0.14 de scikit-learn, actualizada por última vez y ejecutada con Enthought
Pabellón.

Estoy en la plataforma "Windows-7-6.1.7601-SP1".

Profundizaré más dando un ejemplo genérico del problema.
Creo que tiene que ver con GridSearchCV colocado en un bucle for. (Para
no pierda demasiado de su tiempo, probablemente debería comenzar por el
método run_tune_process () que se llama al final del código
y llama al método que contiene GridSearchCV () en un bucle for)
Código:

importar sklearn.metrics como métricas
desde sklearn.grid_search importar GridSearchCV
importar numpy como np
importar sistema operativo
desde sklearn importar conjuntos de datos
desde sklearn importar svm como sk

def tune_hyperparameters (trainingData, período):
allDataTrain = trainingData

# Define hyperparameters and construct a dictionary of them
amount_kernels = 2
kernels = ['rbf','linear']
gamma_range =   10. ** np.arange(-5, 5)
C_range =       10. ** np.arange(-5, 5)
tuned_parameters = [
                    {'kernel': ['rbf'],     'gamma': gamma_range , 'C': C_range},
                    {'kernel': ['linear'],  'C': C_range}
                   ]

print("Tuning hyper-parameters on period = " + str(period) + "\n")

clf = GridSearchCV( sk.SVC(),
                    tuned_parameters,
                    cv=5,
                    pre_dispatch='4*n_jobs',
                    n_jobs=2,
                    verbose = 1,
                    scoring=metrics.make_scorer(metrics.scorer.f1_score, average="macro")
                    )
clf.fit(allDataTrain[:,1:], allDataTrain[:,0:1].ravel())

# other code will output some data to files, graphs and will save the optimal model with joblib package


#   Eventually we will return the optimal model
return clf

def run_tune_process (hyperparam_tuning_method, trainingData, testData):
para el período en np. rango (0,100,10):
clf = hyperparam_tuning_method (trainingData, punto)

            y_real = testData[:,0:1].ravel()
            y_pred = clf.predict(testData[:,1:])

importar algunos datos para jugar

iris = conjuntos de datos.load_iris ()
X_training = iris.data [0: 100 ,:]
Y_training = (iris.target [0: 100]). Remodelar (100,1)
trainingset = np.hstack ((Y_training, X_training))

X_test = iris.data [100: 150 ,:]
Y_test = (iris.target [100: 150]). Remodelar (50,1)
testset = np.hstack ((Y_test, X_test))

run_tune_process (tune_hyperparameters, trainingset, testset)

Responda a este correo electrónico directamente o véalo en Gi
.

Esto no tiene nada que ver con los marcadores personalizados. Esta es una característica bien conocida del multiprocesamiento de Python en Windows: debe ejecutar todo lo que use n_jobs=-1 en un bloque if __name__ == '__main__' o obtendrá bloqueos / bloqueos. ¿Quizás deberíamos documentar esto en algún lugar destacado, por ejemplo, en el archivo README?

tienes que ejecutar todo lo que usa n_jobs = -1 en un if name ==
bloque ' principal ' o obtendrá bloqueos / bloqueos.

Bueno, la buena noticia es que hoy en día joblib da un error significativo
mensaje sobre tal accidente, en lugar de una bomba de horquilla.

@GaelVaroquaux, ¿scikit-learn actual da ese mensaje de error? Si es así, el problema se puede considerar solucionado, en mi humilde opinión.

@GaelVaroquaux, ¿scikit-learn actual da ese mensaje de error? Si es así, el
El problema se puede considerar fijo, en mi humilde opinión.

Debería hacerlo. La única forma de estar seguro es comprobarlo. Me estoy moviendo bien
ahora, y no puedo iniciar una máquina virtual de Windows para hacer eso.

No voy a instalar un compilador de C en Windows solo por esto. Lo siento, pero realmente no uso Windows :)

No voy a instalar un compilador de C en Windows solo por esto. Lo siento pero yo
realmente no hago Windows :)

Tengo una máquina virtual de Windows. Puedo revisarlo. Es solo una cuestión de encontrar un
poco tiempo para hacerlo.

@larsmans , tienes toda la razón. El objeto de marcador personalizado fue un error mío, el problema radica en el multiprocesamiento en Windows. Probé este mismo código en Linux y funciona bien.

No recibo ningún mensaje de error porque no se bloquea, simplemente deja de hacer algo significativo.

@adverley ¿Podrías probar la versión más reciente de GitHub en tu caja de Windows?

Cerrando debido a la falta de retroalimentación y probablemente sea un problema conocido que se corrigió en la biblioteca de trabajos más reciente.

No estoy seguro de si está relacionado, parece estarlo.

En Windows, el marcador personalizado todavía se congela. Encontré este hilo en Google: eliminé el marcador y la búsqueda en la cuadrícula funciona.

Cuando se congela, no muestra ningún mensaje de error. También se generan 3 procesos de Python (porque configuré n_jobs = 3). Sin embargo, la utilización de la CPU sigue siendo 0 para todos los procesos de Python. Estoy usando IPython Notebook.

¿Puedes compartir el código del anotador? Parece un poco improbable.

¿Su anotador usa joblib / n_jobs en algún lugar? No debería, y eso podría causar problemas (aunque creo que joblib debería detectar eso).

Claro, aquí está el código completo: http://pastebin.com/yUE26SNs

La función del marcador es "score_model", no usa joblib.

Esto se ejecuta desde el símbolo del sistema, pero no desde IPython Notebook. El mensaje de error es:
AttributeError: Can't get attribute 'score_model' on <module '__main__' (built-in)>;

Luego, el IPython y todas las instancias de Python generadas se vuelven inactivas, silenciosamente, y ya no responden a ningún código de Python hasta que lo reinicio.

Corrija el error de atributo, entonces funcionará.
¿Hacen importaciones de Pylab en el cuaderno IPython? De lo contrario, todo debería ser igual.

Bueno, no sé qué causa el AttributeError ... Aunque es más probable que esté relacionado con joblibs, ya que _ ocurre solo cuando n_jobs es más de 1_, funciona bien con n_jobs=1 .

El error habla del atributo score_model falta en __main__ , tenga o no un if __name__ == '__main__' en el cuaderno de IPython o no.

(Me di cuenta de que la línea de error se pegó incorrectamente arriba; la edité en la publicación anterior).

No uso pylab.

Aquí está el mensaje de error extendido completo: http://pastebin.com/23y5uHT2

Hum, eso probablemente esté relacionado con problemas de multiprocesamiento en Windows. Quizás @GaelVaroquaux o @ogrisel puedan ayudar.
No sé qué hace el portátil con __name__ == "__main__" .
Intente no definir la métrica en el cuaderno, sino en un archivo separado e impórtelo. Creo que eso lo arreglaría.
Esto no está realmente relacionado con GridSearchCV, sino una interacción interesante entre el multiprocesamiento de Windows, el cuaderno IPython y la biblioteca de trabajos.

chicos ... gracias por el hilo. De todos modos, debería haber revisado este hilo antes, desperdiciado 5 horas de mi tiempo en esto. Intentando ejecutar en procesamiento paralelo. Muchas gracias :)
PARA AGREGAR UN COMENTARIO: todavía está congelado. Enfrenté el mismo problema cuando en presencia de mi propia función de costo make_Score ... mi sistema comienza a congelarse. Cuando no usé la función de costo personalizado, no enfrenté estos congelamientos en el procesamiento paralelo

La mejor forma de convertir estas 5 horas en algo útil para el proyecto sería proporcionarnos un ejemplo independiente que reproduzca el problema.

Estaba experimentando el mismo problema en Windows 10 trabajando en el cuaderno Jupyter tratando de usar un marcador personalizado dentro de una validación cruzada anidada y n_jobs = -1. Recibía el mensaje AttributeError: Can't get attribute 'custom_scorer' on <module '__main__' (built-in)>; .
Como sugirió @amueller , la importación del marcador personalizado en lugar de definirlo en el cuaderno funciona.

Tengo exactamente el mismo problema en OSX 10.10.5

Aquí igual.
OSX 10.12.5

Proporcione un fragmento de código reproducible. Nos encantaría llegar al fondo de esto. Es difícil de entender sin código, incluidos los datos, que nos muestra el problema.

Simplemente ejecute estas líneas en un shell de Python

import numpy as np
from sklearn.decomposition import PCA
from sklearn.svm import SVC
from sklearn.preprocessing import RobustScaler
from sklearn.metrics import classification_report
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_predict

np.random.seed(1234)
X = np.random.sample((1000, 100))
Y = np.random.sample((1000)) > 0.5
svc_pipeline = Pipeline([('pca', PCA(n_components=95)), ('svc', SVC())])
predictions = cross_val_predict(svc_pipeline, X, Y, cv=30, n_jobs=-1)
print classification_report(Y, predictions)

Tenga en cuenta que eliminar el paso de PCA de la canalización resuelve el problema.

Más información:

Darwin-16.6.0-x86_64-i386-64bit
('Python', '2.7.13 (predeterminado, 4 de abril de 2017, 08:47:57) \ n [GCC 4.2.1 Compatible con Apple LLVM 8.1.0 (clang-802.0.38)]')
('NumPy', '1.12.1')
('Ciencia ficción', '0.19.1')
('Scikit-Learn', '0.18.2')

dado que no utiliza un marcador personalizado, deberíamos suponer que es un
tema separado?

El 8 de agosto de 2017 a las 6:15 pm, "boazsh" [email protected] escribió:

Simplemente ejecute estas líneas en un shell de Python

desde sklearn.decomposition importar PCA desde sklearn.svm importar SVC desde sklearn.preprocessing import RobustScaler desde sklearn.metrics importar class_report desde sklearn.pipeline import Pipeline desde sklearn.model_selection import cross_val_predict

X = np.muestra aleatoria ((1000, 100))
Y = np.random.sample ((1000))> 0.5
svc_pipeline = Pipeline ([('pca', PCA (n_components = 95)), ('svc', SVC ())])
predicciones = cross_val_predict (svc_pipeline, X, Y, cv = 30, n_jobs = -1) imprimir informe_clasificación (Y, predicciones)

Tenga en cuenta que eliminar el paso de PCA de la canalización resuelve el problema.

Más información:

scikit-learn == 0.18.2
scipy == 0.19.1
numpy == 1.12.1

-
Estás recibiendo esto porque hiciste un comentario.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment-320885103 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/AAEz6-6Klhc67b5kZ17fFTxc8RfZQ_BWks5sWBkLgaJpZM4BkiD9
.

Cuando me enfrenté a este problema por primera vez, estaba usando un marcador personalizado, pero mientras intentaba simplificar el código de ejemplo tanto como fuera posible, descubrí que no necesariamente tiene que contener un marcador personalizado. Al menos en mi máquina. Importar el anotador tampoco ayudó en mi caso. De todos modos, los síntomas se ven similares. El script se cuelga para siempre y la utilización de la CPU es baja.

@boazsh muchas gracias por el fragmento, aunque no es determinista, puedes editarlo y usar np.random.RandomState para asegurarte de que los números aleatorios sean siempre los mismos en cada ejecución.

También hay una solución alternativa si está utilizando Python 3 sugerido, por ejemplo, en https://github.com/scikit-learn/scikit-learn/issues/5115#issuecomment -187683383.

No tengo una forma de probar esto en OSX en este momento, pero es posible que pueda intentarlo en los próximos días.

Alguna información útil para tener (solo agregue lo que falta a su comentario anterior https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment-320885103):

import platform; print(platform.platform())
import sys; print("Python", sys.version)
import numpy; print("NumPy", numpy.__version__)
import scipy; print("SciPy", scipy.__version__)
import sklearn; print("Scikit-Learn", sklearn.__version__)

Además, ¿cómo instaló scikit-learn, con pip, con conda, con uno de los administradores de paquetes de OSX (brew, etc ...)?

Se actualizó el fragmento (usado np.random.seed)

Darwin-16.6.0-x86_64-i386-64bit
('Python', '2.7.13 (predeterminado, 4 de abril de 2017, 08:47:57) \ n [GCC 4.2.1 Compatible con Apple LLVM 8.1.0 (clang-802.0.38)]')
('NumPy', '1.12.1')
('Ciencia ficción', '0.19.1')
('Scikit-Learn', '0.18.2')

Se actualizó el fragmento (usado np.random.seed)

¡Muchísimas gracias!

Además, ¿cómo instaló scikit-learn, con pip, con conda, con uno de los administradores de paquetes de OSX (brew, etc ...)?

¿Has respondido a esta? No puedo encontrar tu respuesta ...

Lo siento, me lo perdí, pip.

FWIW, no tengo problemas para ejecutar ese fragmento con:

plataforma de importación; imprimir (plataforma.plataforma ())
Darwin-16.7.0-x86_64-i386-64bit
import sys; print ("Python", sys.version)
Python 2.7.12 | Continuum Analytics, Inc. | (predeterminado, 2 de julio de 2016, 17:43:17)
[GCC 4.2.1 (basado en Apple Inc. compilación 5658) (LLVM compilación 2336.11.00)]
import numpy; print ("NumPy", numpy .__ versión__)
NumPy 1.13.1
import scipy; print ("SciPy", scipy .__ versión__)
CIENCIA 0.19.1
importar sklearn; print ("Scikit-Learn", sklearn .__ versión__)
Scikit-Learn 0.18.2

¿Podría poner verbose = 10 en cross_val_predict, también, para que tal vez podamos
¿Ves dónde se rompe para ti?

El 8 de agosto de 2017 a las 22:59, boazsh [email protected] escribió:

Lo siento, me lo perdí, pip.

-
Estás recibiendo esto porque hiciste un comentario.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment-320948362 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/AAEz67S64KIXUGvARGjvxBOw_4aCAdqhks5sWFu0gaJpZM4BkiD9
.

@jnothman Supongo que su entorno de conda usa MKL y no Accelerate. Este problema de congelación es específico del multiprocesamiento de Accelerate y Python. http://scikit-learn.org/stable/faq.html#why -do-i-someime-get-a-crash-freeze-with-n-jobs-1-under-osx-or-linux para obtener más detalles .

pip, por otro lado, usará ruedas que se envían con Accelerate (en el momento de escribir este artículo).

Una solución alternativa (que no sea JOBLIB_START_METHOD) para evitar este error en particular es usar MKL (por ejemplo, a través de conda) u OpenBLAS (por ejemplo, a través del canal conda-forge).

No se imprime nada ...

@jnothman Supongo que su entorno de conda usa MKL y no Accelerate.

@jnothman en caso de que desee reproducir el problema, IIRC puede crear un entorno con Accelerate en OSX con algo como:

conda create -n test-env python=3 nomkl scikit-learn ipython

FWIW No puedo reproducir el problema en mi VM OS X. Traté de imitar lo más cerca posible las versiones de @boazsh :

Darwin-16.1.0-x86_64-i386-64bit
('Python', '2.7.13 |Continuum Analytics, Inc.| (default, Dec 20 2016, 23:05:08) \n[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)]')
('NumPy', '1.12.1')
('SciPy', '0.19.1')
('Scikit-Learn', '0.18.2')

Hmm, en realidad puedo reproducir, pero tu fragmento no era un reproductor completo. Aquí hay un fragmento actualizado:

import numpy as np
from sklearn.decomposition import PCA
from sklearn.svm import SVC
from sklearn.preprocessing import RobustScaler
from sklearn.metrics import classification_report
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_predict

np.random.seed(1234)
X = np.random.sample((1000, 100))
Y = np.random.sample((1000)) > 0.5
svc_pipeline = Pipeline([('pca', PCA(n_components=95)), ('svc', SVC())])
PCA(n_components=95).fit(X, Y) # this line is required to reproduce the freeze
predictions = cross_val_predict(svc_pipeline, X, Y, cv=30, n_jobs=-1)
print(classification_report(Y, predictions))

En cualquier caso, este es un problema conocido con el multiprocesamiento de Accelerate y Python. Existen soluciones alternativas y se han enumerado en publicaciones anteriores. El más fácil es probablemente usar conda y asegurarse de usar MKL y no Accelerate.

A más largo plazo (probablemente scikit-learn 0.20), este problema será resuelto universalmente por el nuevo backend loky para joblib: https://github.com/scikit-learn/scikit-learn/issues/7650

Tener una solución para que el multiprocesamiento dependa de la versión de scikit-learn es sintomático de los problemas de venta ...

Tener una solución para que el multiprocesamiento dependa de la versión de scikit-learn es sintomático de los problemas de venta ...

Recientemente leí lo siguiente, que me pareció interesante:
https://lwn.net/Articles/730630/rss

Tengo un problema similar con RandomizedSearchCV; cuelga indefinidamente. Estoy usando un macbook pro de 3 años, 16GB de ram y core i7 y mi versión de scikit-learn es 0.19.

¡La parte desconcertante es que estuvo funcionando el viernes pasado! El lunes por la mañana, vuelvo y trato de correr y simplemente se congela. Sé por las ejecuciones anteriores que se tarda unos 60 minutos en terminar, pero esperé mucho más que eso y no pasa nada, simplemente se cuelga, no hay mensajes de error, nada y mi computadora se calienta y consume energía como si no hubiera un mañana. Código a continuación. Intenté cambiar n_iter a 2 y n_jobs = 1 después de leer algunos comentarios aquí y funcionó. Entonces puede tener algo que ver con n_jobs = -1. Aún así, ¡este código funcionó bien el viernes pasado! simplemente odia los lunes. El tamaño de mi conjunto de datos es menos de 20k ejemplos con dimensionalidad <100 ..

from sklearn.metrics import make_scorer
from sklearn.cross_validation import cross_val_score
from sklearn.grid_search import RandomizedSearchCV
import sklearn_crfsuite

crf = sklearn_crfsuite.CRF(
    algorithm='lbfgs', 
    max_iterations=100, 
    all_possible_transitions=True
)
params_space = {
    'c1': scipy.stats.expon(scale=0.5),
    'c2': scipy.stats.expon(scale=0.05),
}

f1_scorer = make_scorer(metrics.flat_f1_score, 
                        average='weighted', labels=labels)
rs = RandomizedSearchCV(crf, params_space, 
                        cv=3, 
                        verbose=1, 
                        n_jobs=-1, 
                        n_iter=50, 
                        scoring=f1_scorer)

rs.fit(X_train, y_train)  # THIS IS WHERE IT FREEZES

que es crf? solo para eliminar la posibilidad, ¿podría intentar usar
return_train_score = ¿Falso?

Es muy probable que este problema de @KaisJM se deba a la conocida limitación de Accelerate con multiprocesamiento, consulte nuestras faq .

¿Cómo instalaste scikit-learn?

También para referencia futura, ¿puede pegar la salida de:

import platform; print(platform.platform())
import sys; print("Python", sys.version)
import numpy; print("NumPy", numpy.__version__)
import scipy; print("SciPy", scipy.__version__)
import sklearn; print("Scikit-Learn", sklearn.__version__)

esto estaba funcionando el viernes pasado !! No hice nada desde entonces. Creo que scikit learn es parte de anaconda, pero actualicé con pip (pip install --upgrade sklearn), pero eso fue antes de que tuviera este problema. Ejecuté bien el código después de actualizar a 0.19.

aquí está la salida de las impresiones anteriores:

Darwin-15.6.0-x86_64-i386-64bit
('Python', '2.7.12 |Continuum Analytics, Inc.| (default, Jul  2 2016, 17:43:17) \n[GCC 4.2.1 (Based on Apple Inc. build 5658) (LLVM build 2336.11.00)]')
('NumPy', '1.13.1')
('SciPy', '0.19.1')
('Scikit-Learn', '0.19.0')

@jnothman : Estoy usando RandomizedSearchCV de sklearn.grid_search que no tiene el parámetro return_train_score. Sé que sklearn.grid_search está depricado. Probaré el de sklearn.model_selection, pero algo me dice que tendré exactamente el mismo problema). Comentario original actualizado con más información y código.

¿Puede publicar la salida de conda list | grep numpy . Me atrevería a suponer que al actualizar scikit-learn con pip, también actualizaste numpy con pip y obtuviste las ruedas numpy que usa Accelerate y tiene la limitación mencionada anteriormente.

Un pequeño consejo:

• publique un fragmento completamente independiente (para su próximo número). Eso significa que cualquiera puede copiarlo y pegarlo en una sesión de IPython e intentar reproducirlo fácilmente. Esto le dará la mejor oportunidad de obtener una buena retroalimentación.
• si está usando conda, apéguese a conda para administrar los paquetes que están disponibles a través de conda. Solo use pip cuando sea necesario.
• Si insiste en que desea utilizar pip install --update , le recomiendo encarecidamente que utilice pip install --update --no-deps . De lo contrario, si un paquete depende, digamos de numpy, y resulta que no tiene el último numpy, numpy se actualizará con pip, que no desea.

Ah, sí, y por cierto, sklearn.grid_search está obsoleto, probablemente quieras usar sklearn.model_selection en un punto no muy lejano en el futuro.

Buen consejo, gracias. Entonces, ¿es la solución para degradar numpy? ¿A qué limitación te refieres? el enlace de preguntas frecuentes de arriba? Lo leí, pero no entiendo estas cosas (solo soy un tipo de algo :)).

salida de conda list | grep numpy

numpy 1.12.0
numpy 1.12.0 py27_0
numpy 1.13.1
numpydoc 0.7.0

Wow, tres numpy instalados, vi dos antes, pero nunca tres ... de todos modos, esto parece indicativo del problema que estaba mencionando, es decir, que ha mezclado pip y conda, lo cual es una mala idea para un paquete determinado.

pip uninstall -y # maybe a few times to make sure you have removed pip installed packages
conda install numpy -f

Con suerte, después de eso, tendrá un solo número que usa MKL.

Si yo fuera usted, comprobaría que no tiene el mismo problema para otros paquetes científicos básicos, por ejemplo, scipy, etc.

la razón por la que recurro a pip para algunos paquetes es que conda no tiene algunos paquetes, lo que en realidad es muy frustrante porque sé que mezclar pip con conda es una mala idea. La próxima vez que eso suceda, usaré la opción --no-deps.

Una cosa que debería haber mencionado es que instalé Spyder dentro del entorno de Python en el que estaba trabajando. Sin embargo, pude ejecutar el código después de instalar Spyder, tanto en Spyder como en Jupyter.

Desinstalé Spyder y los numpys anteriores, volví a instalar baches con conda (que actualizó scikit a 0.19) y aún obtengo el mismo error. Algo puede haber sucedido debido a la instalación de Spyder, pero entonces ¿por qué funcionaría durante un día y luego se detendría repentinamente?

ok, nada funciona !! ¿Debería crear un nuevo entorno (usando conda) y reinstalar todo allí? ¿Eso lo resolverá o lo empeorará?

¡Vale la pena intentarlo!

creó un nuevo env e instalé todo con conda, todavía se congela indefinidamente. solo una copia de cada paquete, etc.

n_jobs = 1 funciona, pero lleva una eternidad, por supuesto (también funcionó en el entorno anterior). n_jobs = -1 es lo que se congela indefinidamente.

conda list | grep numpy
numpy                     1.13.1           py27hd567e90_2


Darwin-15.6.0-x86_64-i386-64bit
('Python', '2.7.13 |Continuum Analytics, Inc.| (default, Dec 20 2016, 23:05:08) \n[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)]')
('NumPy', '1.13.1')
('SciPy', '0.19.1')
('Scikit-Learn', '0.19.0')

Entonces no lo se. La única forma en que podemos investigar es que publique un fragmento de código completamente independiente que podamos copiar y pegar en una sesión de IPython y ver si podemos reproducir el problema.

Intentará crear un ejemplo mínimo que reproduzca el problema. Necesito hacer eso para depurar de manera más eficiente.

Leí la entrada de preguntas frecuentes a la que te refieres sobre "Acelerar" ... no me ayuda mucho. Lo que tomé de él es que fork () NO seguido de la llamada exec () es malo. Hice algunas búsquedas en Google sobre esto y hasta ahora nada sugiere una solución alternativa. ¿Puede señalar más información, más detalles sobre cuál es el problema? Gracias,

Pruebe este fragmento (tomado de https://github.com/numpy/numpy/issues/4776):

import multiprocessing as mp

import numpy as np


def compute(n):
    print('Enter')
    np.dot(np.eye(n), np.eye(n))
    print('Exit')


print('\nWithout multiprocessing:')
compute(1000)

print('\nWith multiprocessing:')
workers = mp.Pool(1)
results = workers.map(compute, (1000, 1000))

• Si esto se congela (es decir, no termina en un segundo), significa que está usando Accelerate y la congelación es una limitación conocida con el multiprocesamiento de Python. La solución es no usar Accelerate. En OSX, puede hacerlo con conda, que usa MKL de forma predeterminada. También puede usar OpenBLAS usando conda-forge.
• Si no se congela, entonces no estás usando Accelerate y necesitaríamos un fragmento independiente para investigar.

intentará reproducirse con un código mínimo.

Without multiprocessing:
Enter
Exit

With multiprocessing:
Enter
Exit
Enter
Exit

@GaelVaroquaux scikit-learn no es una aplicación, sino una biblioteca en un ecosistema rico. Si todos hicieran lo que nosotros hacemos, todo se derrumbaría. Esa es una señal bastante clara de que tenemos que cambiar. Y hay muchos entornos donde ocurre lo contrario de ese comentario.

Usé una instancia virtual de ubuntu en el motor de cómputo en la nube de Google (con baches, picantes, scikit, etc.no eran los más actualizados). El código funcionó bien. Luego instalé Gensim. Esto actualizó numpy y scipy a las últimas versiones e instaló algunas otras cosas que necesita (boto, bz2file y smart_open). Después de eso, el código se congela. Espero que esto dé una pista útil sobre las causas de esta congelación.

después de instalar Gensim
numpy (1.10.4) actualizado a numpy (1.13.3)
scipy (0.16.1) actualizado a scipy (0.19.1)

más información:
Investigando un poco, encontré que libblas, liblapack y liblapack_atlas faltaban en mi / usr / lib /, y tampoco vi el directorio / usr / lib / atlas-base /. No sé si estaban allí y la instalación de gensim los eliminó, ya que actualizó numpy, etc., pero esto es probable porque el código funcionó antes de instalar gensim. Los instalé usando sudo apt-get --yes install libatlas-base-dev y "_update-alternativas_" de acuerdo con las instrucciones avanzadas de

Creo que el problema es que numpy está usando OpenBlas. Lo cambiará a ATLAS y verá qué sucede.

>>> import numpy as np
>>> np.__config__.show()
lapack_opt_info:
    libraries = ['openblas']
    library_dirs = ['/usr/local/lib']
    define_macros = [('HAVE_CBLAS', None)]
    language = c
blas_opt_info:
    libraries = ['openblas']
    library_dirs = ['/usr/local/lib']
    define_macros = [('HAVE_CBLAS', None)]
    language = c
openblas_info:
    libraries = ['openblas']
    library_dirs = ['/usr/local/lib']
    define_macros = [('HAVE_CBLAS', None)]
    language = c
openblas_lapack_info:
    libraries = ['openblas']
    library_dirs = ['/usr/local/lib']
    define_macros = [('HAVE_CBLAS', None)]
    language = c
blas_mkl_info:
  NOT AVAILABLE

Sigue siendo el mismo problema. Lo siguiente funciona bien, a menos que inserte n_jobs = -1.

from sklearn.metrics import fbeta_score

def f2_score(y_true, y_pred):
    y_true, y_pred, = np.array(y_true), np.array(y_pred)
    return fbeta_score(y_true, y_pred, beta=2, average='binary')

clf_rf = RandomForestClassifier()
grid_search = GridSearchCV(clf_rf, param_grid=param_grid, scoring=make_scorer(f2_score), cv=5)
grid_search.fit(X_train, y_train)  

@paulaceccon, ¿sus instalaciones de Numpy y Scipy utilizan ATLAS u OpenBLAS?

Es un poco difícil seguir lo que has hecho @KaisJM. Desde el punto de vista de un mantenedor, lo que necesitamos es un fragmento de Python completamente independiente para ver si podemos reproducirlo. Si podemos reproducirnos, solo entonces podremos investigar e intentar comprender lo que está sucediendo. Si eso solo sucede cuando instala gensim y logra reproducir este comportamiento de manera consistente, entonces necesitaríamos instrucciones completas sobre cómo crear un entorno Python que tiene el problema frente a un entorno Python que no tiene el problema.

Esto requiere una cantidad no despreciable de tiempo y esfuerzo, estoy completamente de acuerdo, pero sin él, me temo que no hay mucho que podamos hacer para investigar el problema al que se enfrenta.

de acuerdo con las instrucciones de instalación avanzadas

@KaisJM por cierto, esta página está desactualizada, ya que hoy en día las ruedas están disponibles en Linux y contienen su propio OpenBLAS. Si instala un scikit-learn publicado con pip, estará usando OpenBLAS.

@lesteve, ¿estás diciendo que Openblas ya no causa un congelamiento?

@lesteve paula ha publicado un fragmento que también tiene el mismo problema. Puedo ver que no es un código completo, pero espero que dé alguna pista. Puedo hacer que el fragmento esté "completo" y publicarlo para usted. Sin embargo, está claro que la página de instrucciones "desactualizada" -como usted la llama- puede no estar tan desactualizada. La mayor probabilidad es que OpenBLAS esté causando las tarifas de las que están hablando en esa página.

Estas instrucciones están desactualizadas, créame. Si lee los detalles, dice "pero puede congelar joblib / multiprocessing antes de OpenBLAS versión 0.2.8-4". Revisé una rueda numérica reciente y contiene OpenBLAS 0.2.8.18. La congelación a la que se refieren es la que está en https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment -334155175, que no parece tener.

Puedo ver que no es un código completo, pero espero que dé alguna pista

No, realmente no. Tenemos informes de usuarios que parecen indicar que la congelación aún puede ocurrir, ninguno de los cuales hemos logrado reproducir AFAIK. Eso parece indicar que este problema ocurre en una combinación muy específica de factores. A menos que alguien que tiene el problema pase algo de tiempo y descubra cómo reproducirse de forma controlada y logremos reproducirnos, no hay forma de que podamos hacer nada al respecto.

Puedo hacer que el fragmento esté "completo" y publicarlo para usted.

Eso seria genial. Sería genial si pudiera comprobar si dicho fragmento todavía causa la congelación en un entorno de conda separado (o virtualenv dependiendo de lo que use).

@lesteve @paulaceccon : Tomé el código de extracto de Paula e hice un fragmento de código completo ejecutable. Simplemente péguelo en una celda de Jupyter y ejecútelo. Paula: No pude congelar este fragmento. Tenga en cuenta que n_jobs = -1 y funciona bien. Sería genial si pudieras echarle un vistazo y publicar una versión que se congele. Tenga en cuenta que puede cambiar entre el módulo grid_search y el módulo model_selection, ambos funcionaron bien para mí.

import platform; print(platform.platform())
import sys; print("Python", sys.version)
import numpy as np; print("NumPy", np.__version__)
import scipy; print("SciPy", scipy.__version__)
import sklearn; print("Scikit-Learn", sklearn.__version__)

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification

import scipy.stats
from sklearn.metrics import make_scorer
from sklearn.grid_search import RandomizedSearchCV
#from sklearn.model_selection import RandomizedSearchCV
#from sklearn.model_selection import GridSearchCV
from sklearn.metrics import fbeta_score

X, y = make_classification(n_samples=1000, n_features=4,
                           n_informative=2, n_redundant=0,
                           random_state=0, shuffle=False)

clf_rf = RandomForestClassifier(max_depth=2, random_state=0)

def f2_score(y_true, y_pred):
    y_true, y_pred, = np.array(y_true), np.array(y_pred)
    return fbeta_score(y_true, y_pred, beta=2, average='binary')

param_grid = {'max_depth':[2, 3, 4], 'random_state':[0, 3, 7, 17]}

grid_search = RandomizedSearchCV(clf_rf, param_grid, n_jobs=-1, scoring=make_scorer(f2_score), cv=5)

grid_search.fit(X, y)

@KaisJM Creo que es más útil si comienzas desde tu script de congelación y logras simplificar y publicar un

@lesteve estuvo de acuerdo. Creé un nuevo entorno python2 como el que tenía antes de instalar Gensim. El código funcionó bien, NO congelar con n_jobs = -1. Además, Numpy está usando OpenBLAS y tiene la misma configuración que el entorno que exhibe la congelación (en el que se instaló Gensim). Entonces parece que openblas no es la causa de esta congelación.

bumpy.__config__.show()
lapack_opt_info:
    libraries = ['openblas']
    library_dirs = ['/usr/local/lib']
    define_macros = [('HAVE_CBLAS', None)]
    language = c
blas_opt_info:
    libraries = ['openblas']
    library_dirs = ['/usr/local/lib']
    define_macros = [('HAVE_CBLAS', None)]
    language = c
openblas_info:
    libraries = ['openblas']
    library_dirs = ['/usr/local/lib']
    define_macros = [('HAVE_CBLAS', None)]
    language = c
openblas_lapack_info:
    libraries = ['openblas']
    library_dirs = ['/usr/local/lib']
    define_macros = [('HAVE_CBLAS', None)]
    language = c
blas_mkl_info:
  NOT AVAILABLE

@KaisJM Estoy ejecutando el mismo fragmento aquí (Windows) y se congela.

from sklearn.datasets import make_classification
X, y = make_classification()

from sklearn.ensemble import RandomForestClassifier
clf_rf_params = {
    'n_estimators': [400, 600, 800],
    'min_samples_leaf' : [5, 10, 15],
    'min_samples_split' : [10, 15, 20],
    'criterion': ['gini', 'entropy'],
    'class_weight': [{0: 0.51891309,  1: 13.71835531}]
}

import numpy as np
def ginic(actual, pred):
    actual = np.asarray(actual) # In case, someone passes Series or list
    n = len(actual)
    a_s = actual[np.argsort(pred)]
    a_c = a_s.cumsum()
    giniSum = a_c.sum() / a_s.sum() - (n + 1) / 2.0
    return giniSum / n

def gini_normalizedc(a, p):
    if p.ndim == 2:  # Required for sklearn wrapper
        p = p[:,1]   # If proba array contains proba for both 0 and 1 classes, just pick class 1
    return ginic(a, p) / ginic(a, a)

from sklearn import metrics
gini_sklearn = metrics.make_scorer(gini_normalizedc, True, True)

from sklearn.model_selection import GridSearchCV

clf_rf = RandomForestClassifier()
grid = GridSearchCV(clf_rf, clf_rf_params, scoring=gini_sklearn, cv=3, verbose=1, n_jobs=-1)
grid.fit(X, y)

print (grid.best_params_)

Sé que es incómodo, pero no se congeló cuando se ejecuta con una métrica _custom_.

Tengo un problema similar. He estado ejecutando el mismo código y simplemente quería actualizar el modelo con los datos del nuevo mes y dejó de funcionar. Creo que sklearn se actualizó mientras tanto a 0.19

Ejecutar GridSearchCV o RandomizedSearchCV en un bucle y n_jobs> 1 se colgaría silenciosamente en Jupiter e IntelliJ:

for trial in tqdm(range(NUM_TRIALS)):
    ...
    gscv = GridSearchCV(estimator=estimator, param_grid=param_grid,
                          scoring=scoring, cv=cv, verbose=1, n_jobs=-1)
    gscv.fit(X_data, y_data)

    ...

Se siguió la recomendación de @lesteve y se verificó el entorno y se eliminó el numpy instalado con pip:

Darwin-16.6.0-x86_64-i386-64bit
Python 3.6.1 | Anaconda personalizado (x86_64) | (predeterminado, 11 de mayo de 2017, 13:04:09)
[GCC 4.2.1 Compatible con Apple LLVM 6.0 (clang-600.0.57)]
NumPy 1.13.1
CIENCIA 0.19.1
Scikit-Learn 0.19.0

$ conda list | grep numpy
gnumpy 0.2 pip
numpy 1.13.1 py36_0
numpy 1.13.3 pip
numpydoc 0.6.0 py36_0

$ pip desinstalar numpy

$ conda list | grep numpy
gnumpy 0.2 pip
numpy 1.13.1 py36_0
numpydoc 0.6.0 py36_0

$ conda install numpy -f // muy probablemente innecesario

$ conda list | grep numpy
gnumpy 0.2 pip
numpy 1.13.1 py36_0
numpydoc 0.6.0 py36_0

Arreglado mi problema.

@paulaceccon tu problema está relacionado con

https://stackoverflow.com/questions/36533134/cant-get-attribute-abc-on-module-main-from-abc-h-py
Si declara el grupo antes de declarar la función que está intentando usar en paralelo, arrojará este error. Invierta el orden y ya no arrojará este error.

Lo siguiente ejecutará su código:

import multiprocessing

if __name__ == '__main__':
    multiprocessing.set_start_method('spawn')

    from external import *

    from sklearn.datasets import make_classification
    X, y = make_classification()

    from sklearn.ensemble import RandomForestClassifier
    clf_rf_params = {
        'n_estimators': [400, 600, 800],
        'min_samples_leaf' : [5, 10, 15],
        'min_samples_split' : [10, 15, 20],
        'criterion': ['gini', 'entropy'],
        'class_weight': [{0: 0.51891309,  1: 13.71835531}]
    }

    from sklearn.model_selection import GridSearchCV

    clf_rf = RandomForestClassifier()
    grid = GridSearchCV(clf_rf, clf_rf_params, scoring=gini_sklearn, cv=3, verbose=1, n_jobs=-1)
    grid.fit(X, y)

    print (grid.best_params_)

con external.py

import numpy as np
def ginic(actual, pred):
    actual = np.asarray(actual) # In case, someone passes Series or list
    n = len(actual)
    a_s = actual[np.argsort(pred)]
    a_c = a_s.cumsum()
    giniSum = a_c.sum() / a_s.sum() - (n + 1) / 2.0
    return giniSum / n

def gini_normalizedc(a, p):
    if p.ndim == 2:  # Required for sklearn wrapper
        p = p[:,1]   # If proba array contains proba for both 0 and 1 classes, just pick class 1
    return ginic(a, p) / ginic(a, a)

from sklearn import metrics
gini_sklearn = metrics.make_scorer(gini_normalizedc, True, True)

Resultados que se ejecutan en 8 núcleos

Colocando 3 pliegues para cada uno de 54 candidatos, totalizando 162 ajustes
{'class_weight': {0: 0.51891309, 1: 13.71835531}, 'criterio': 'gini', 'min_samples_leaf': 10, 'min_samples_split': 20, 'n_estimators': 400}

El problema sigue ahí chicos. Estoy usando un marcador personalizado y sigue funcionando para siempre cuando configuro n_jobs en cualquier cosa. Cuando no especifico n_jobs en absoluto, funciona bien, pero por lo demás se congela.

¿Puede proporcionar un fragmento independiente para reproducir el problema? Lea https://stackoverflow.com/help/mcve para obtener más detalles.

Aún enfrenta este problema con el mismo código de muestra.

Windows-10-10.0.15063-SP0
Python 3.6.4 | Anaconda personalizado (64 bits) | (predeterminado, 16 de enero de 2018, 10:22:32) [MSC v.1900 64 bit (AMD64)]
NumPy 1.14.1
Ciencia ficción 1.0.0
Scikit-Learn 0.19.1

¿Puede proporcionar un fragmento independiente para reproducir el problema? Lea https://stackoverflow.com/help/mcve para obtener más detalles.

Sospecho que este es el mismo problema de multiprocesamiento en Windows. ver nuestras preguntas frecuentes

Probé el código en https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment -337985212 de thomberg1.

SO: Windows 10 x64 10.0.16299.309
Paquete de Python: WinPython-64bit-3.6.1
numpy (1.14.2)
scikit-learn (0.19.1)
scipy (1.0.0)

Funcionó bien en Jupyter Notebook y en la línea de comandos.

Hola, estoy teniendo el mismo problema, así que no quería abrir uno nuevo, lo que podría llevar a un hilo casi idéntico.

-Mac OS
-Anaconda
-scikit-learn 0.19.1
-scipy 1.0.1
-numpy 1.14.2

# MLP for Pima Indians Dataset with grid search via sklearn
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasClassifier
from sklearn.model_selection import GridSearchCV
import numpy

# Function to create model, required for KerasClassifier
def create_model(optimizer='rmsprop', init='glorot_uniform'):
  # create model
  model = Sequential()
  model.add(Dense(12, input_dim=8, kernel_initializer=init, activation='relu'))
  model.add(Dense(8, kernel_initializer=init, activation='relu'))
  model.add(Dense(1, kernel_initializer=init, activation='sigmoid'))
  # Compile model
  model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
  return model

# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)
# load pima indians dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]


# create model
model = KerasClassifier(build_fn=create_model, verbose=0)
# grid search epochs, batch size and optimizer
optimizers = ['rmsprop', 'adam']
init = ['glorot_uniform', 'normal', 'uniform']
epochs = [50, 100, 150]
batches = [5, 10, 20]
param_grid = dict(optimizer=optimizers, epochs=epochs, batch_size=batches, init=init)
grid = GridSearchCV(estimator=model, param_grid=param_grid)
grid_result = grid.fit(X, Y)
# summarize results
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
  print("%f (%f) with: %r" % (mean, stdev, param))

El código es de un tutorial: https://machinelearningmastery.com/use-keras-deep-learning-models-scikit-learn-python/
Intenté cambiar el parámetro n_jobs a 1, -1, pero ninguno de estos funcionó. ¿Alguna pista?

se ejecuta si agrego la importación de multiprocesamiento y la declaración if como se muestra a continuación: no trabajo con keras, así que no tengo más información

import multiprocessing

if __name__ == '__main__':

    # MLP for Pima Indians Dataset with grid search via sklearn
    from keras.models import Sequential
    from keras.layers import Dense
    from keras.wrappers.scikit_learn import KerasClassifier
    from sklearn.model_selection import GridSearchCV
    import numpy

    # Function to create model, required for KerasClassifier
    def create_model(optimizer='rmsprop', init='glorot_uniform'):
      # create model
      model = Sequential()
      model.add(Dense(12, input_dim=8, kernel_initializer=init, activation='relu'))
      model.add(Dense(8, kernel_initializer=init, activation='relu'))
      model.add(Dense(1, kernel_initializer=init, activation='sigmoid'))
      # Compile model
      model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
      return model

    # fix random seed for reproducibility
    seed = 7
    numpy.random.seed(seed)
    # load pima indians dataset
    dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
    # split into input (X) and output (Y) variables
    X = dataset[:,0:8]
    Y = dataset[:,8]


    # create model
    model = KerasClassifier(build_fn=create_model, verbose=0)
    # grid search epochs, batch size and optimizer
    optimizers = ['rmsprop', 'adam']
    init = ['glorot_uniform', 'normal', 'uniform']
    epochs = [5]
    batches = [5, 10, 20]
    param_grid = dict(optimizer=optimizers, epochs=epochs, batch_size=batches, init=init)
    grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=12, verbose=1)
    grid_result = grid.fit(X, Y)
    # summarize results
    print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
    means = grid_result.cv_results_['mean_test_score']
    stds = grid_result.cv_results_['std_test_score']
    params = grid_result.cv_results_['params']
    for mean, stdev, param in zip(means, stds, params):
      print("%f (%f) with: %r" % (mean, stdev, param))

Colocando 3 pliegues para cada uno de los 18 candidatos, totalizando 54 ajustes

Mejor: 0.675781 usando {'batch_size': 5, 'epochs': 5, 'init': 'glorot_uniform', 'optimizer': 'adam'}
0.621094 (0.036225) con: {'batch_size': 5, 'epochs': 5, 'init': 'glorot_uniform', 'optimizer': 'rmsprop'}
0.675781 (0.006379) con: {'batch_size': 5, 'epochs': 5, 'init': 'glorot_uniform', 'optimizer': 'adam'}
...
0.651042 (0.025780) con: {'batch_size': 20, 'epochs': 5, 'init': 'uniform', 'optimizer': 'adam'}

información de la versión si es necesario
sys 3.6.4 | Anaconda personalizado (64 bits) | (predeterminado, 16 de enero de 2018, 12:04:33)
[GCC 4.2.1 Compatible con Clang 4.0.1 (etiquetas / RELEASE_401 / final)]
numpy 1.14.2
pandas 0.22.0
sklearn 0.19.1
antorcha 0.4.0a0 + 9692519
IPython 6.2.1
keras 2.1.5

compilador: GCC 4.2.1 Compatible Clang 4.0.1 (etiquetas / RELEASE_401 / final)
sistema: Darwin
lanzamiento: 17.5.0
máquina: x86_64
procesador: i386
Núcleos de CPU: 24
intérprete: 64bit

Gracias @ thomberg1 , pero agregando

import multiprocessing
if __name__ == '__main__':

no ayudó. El problema sigue siendo el mismo

El mismo problema en mi máquina cuando uso la función de puntuación personalizada en GridsearchCV .
python 3.6.4,
scikit-learn 0.19.1,
ventanas 10.,
Núcleos de CPU: 24

@byrony, ¿ puede proporcionar un código para reproducir? ¿usaste if __name__ == "__main__" ?

Experimenté un problema similar varias veces en mi máquina al usar n_jobs=-1 o n_jobs=8 como argumento para GridsearchCV pero usando el argumento de marcador predeterminado.

• Python 3.6.5,
• scikit-learn 0.19.1,
• Arch Linux,
• Núcleos de CPU: 8.

Aquí está el código que utilicé:

from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import MinMaxScaler
from sklearn.decomposition import PCA
from sklearn.utils import shuffle
from sklearn.neural_network import MLPClassifier
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np


def main():

    df = pd.read_csv('../csvs/my_data.csv', nrows=4000000)    

    X = np.array(list(map(lambda a: np.fromstring(a[1:-1] , sep=','), df['X'])))
    y = np.array(list(map(lambda a: np.fromstring(a[1:-1] , sep=','), df['y'])))

    scalerX = MinMaxScaler()
    scalerY = MinMaxScaler()
    X = scalerX.fit_transform(X)
    y = scalerY.fit_transform(y)

    grid_params = {
        'beta_1': [ .1, .2, .3, .4, .5, .6, .7, .8, .9 ],
        'activation': ['identity', 'logistic', 'tanh', 'relu'],
        'learning_rate_init': [0.01, 0.001, 0.0001]
    }

    estimator = MLPClassifier(random_state=1, 
                              max_iter=1000, 
                              verbose=10,
                              early_stopping=True)

    gs = GridSearchCV(estimator, 
                      grid_params, 
                      cv=5,
                      verbose=10, 
                      return_train_score=True,
                      n_jobs=8)

    X, y = shuffle(X, y, random_state=0)

    y = y.astype(np.int16)    

    gs.fit(X, y.ravel())

    print("GridSearchCV Report \n\n")
    print("best_estimator_ {}".format(gs.best_estimator_))
    print("best_score_ {}".format(gs.best_score_))
    print("best_params_ {}".format(gs.best_params_))
    print("best_index_ {}".format(gs.best_index_))
    print("scorer_ {}".format(gs.scorer_))
    print("n_splits_ {}".format(gs.n_splits_))

    print("Exporting")
    results = pd.DataFrame(data=gs.cv_results_)
    results.to_csv('../csvs/gs_results.csv')


if __name__ == '__main__':
    main()

Sé que es un gran conjunto de datos, así que esperaba que tomara algún tiempo obtener resultados, pero luego de 2 días de ejecución, simplemente dejó de funcionar (el script sigue ejecutándose pero no usa ningún recurso aparte de la RAM y el intercambio).

¡Gracias por adelantado!

@amueller No if __name__ == "__main__" . A continuación se muestra mi código, solo funciona cuando n_jobs=1

def neg_mape(true, pred):
    true, pred = np.array(true)+0.01, np.array(pred)
    return -1*np.mean(np.absolute((true - pred)/true))

xgb_test1 = XGBRegressor(
    #learning_rate =0.1,
    n_estimators=150,
    max_depth=3,
    min_child_weight=1,
    gamma=0,
    subsample=0.8,
    colsample_bytree=0.8,
    objective= 'reg:linear',
    nthread=4,
    scale_pos_weight=1,
    seed=123,
)

param_test1 = {
    'learning_rate':[0.01, 0.05, 0.1, 0.2, 0.3],
}

gsearch1 = GridSearchCV(estimator = xgb_test1, param_grid = param_test1, scoring=neg_mape, n_jobs=4, cv = 5)

Estás usando XGBoost. No sé qué hacen internamente, es muy posible que ese sea el problema. ¿Puedes intentar ver si agregar if __name__ ayuda?
De lo contrario, no creo que haya una solución para eso todavía.

@ Pazitos10 ¿se puede reproducir con datos sintéticos y / o datos más pequeños? No puedo reproducir sin sus datos y sería bueno reproducirlo en menos tiempo.

@amueller Ok, lo ejecutaré nuevamente con 500k filas y publicaré los resultados. ¡Gracias!

@amueller , ejecutar el script con 50k filas funciona como se esperaba. El script termina correctamente, mostrando los resultados de la siguiente manera (lo siento, quise decir 50k, no 500k):

El problema es que no sé si estos resultados serán los mejores para todo mi conjunto de datos. ¿Algún consejo?

Parece que te estás quedando sin memoria RAM. Tal vez intente usar Keras en su lugar, es probable que sea una mejor solución para redes neuronales a gran escala.

@amueller Oh, está bien. Intentaré usar Keras en su lugar. ¡Gracias de nuevo!

Esto no tiene nada que ver con los marcadores personalizados. Esta es una característica bien conocida del multiprocesamiento de Python en Windows: debe ejecutar todo lo que use n_jobs=-1 en un bloque if __name__ == '__main__' o obtendrá bloqueos / bloqueos. ¿Quizás deberíamos documentar esto en algún lugar destacado, por ejemplo, en el archivo README?

¿Es quizás una idea para scikit, que en el caso de Windows para alterar la función
Y utilice colas para alimentar tareas a una colección de procesos de trabajo y recopilar los resultados.
Como se describe aquí: https://docs.python.org/2/library/multiprocessing.html#windows
y para 3.6 aquí: https://docs.python.org/3.6/library/multiprocessing.html#windows

@PGTBoos esto está arreglado en scikit-learn 0.20.0