Isso é surpreendente, então teremos que descobrir qual é o problema e nos certificar de que funcione!

Você pode fornecer mais detalhes:

• O que você quer dizer com "travamentos"?
• Que versão do scikit-learn é essa? Se for 0,14, ainda ocorre na versão de desenvolvimento atual?
• O multiprocessamento tem problemas específicos da plataforma. Em que plataforma você está? (por exemplo, import platform; platform.platform() )
• Você já experimentou em diferentes conjuntos de dados?

FWIW, minha máquina não tem problemas para ajustar a íris com este snippet na versão de desenvolvimento do sklearn.

Obrigado pela sua resposta rápida.

Com crashing, na verdade quero dizer congelamento. Não continua mais e também não há mais atividade a ser monitorada no processo python do gerenciador de tarefas do Windows. Os processos ainda estão lá e consomem uma quantidade constante de RAM, mas não requerem tempo de processamento.

Esta é a versão 0.14 do scikit-learn, atualizada pela última vez e executada usando o Enthought Canopy.

Estou na plataforma "Windows-7-6.1.7601-SP1".

Aprofundarei mais, fornecendo um exemplo genérico do problema. Acho que tem a ver com o GridSearchCV sendo colocado em um loop for. (Para não perder muito tempo, você provavelmente deve começar com o método run_tune_process () que está sendo chamado na parte inferior do código e chama o método que contém GridSearchCV () em um loop 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)

Mais uma vez, este código funciona no meu computador apenas quando eu altero n_jobs para 1 ou quando não defino um argumento scoring =.

Geralmente, o multiprocessamento no Windows encontra muitos problemas. Mas eu
não sei por que isso deve ser correlacionado com uma métrica personalizada. Há
nada sobre a opção média = macro em 0,14 que sugira que deveria ser
mais probabilidade de travar do que a média padrão (ponderada). No desenvolvimento
cabeça, isso termina em 11s no meu macbook e em 7s na versão 0.14
(isso é algo para se olhar!)

Você é capaz de experimentar na versão de desenvolvimento atual, para ver se
ainda é um problema?

Em 25 de fevereiro de 2014 20:40, adverley [email protected] escreveu:

Obrigado pela sua resposta rápida.

Com crashing, na verdade quero dizer congelamento. Não continua mais e
também não há mais atividade a ser monitorada no processo python de
gerenciador de tarefas do Windows. Os processos ainda estão lá e consomem um
quantidade constante de RAM, mas não requer tempo de processamento.

Esta é a versão 0.14 do scikit-learn, atualizada pela última vez e executada usando o Enthought
Marquise.

Estou na plataforma "Windows-7-6.1.7601-SP1".

Aprofundarei mais, fornecendo um exemplo genérico do problema. eu
acho que tem a ver com o GridSearchCV sendo colocado em um loop for. (Para
não perca muito do seu tempo, você provavelmente deve começar no
método run_tune_process () que está sendo chamado na parte inferior do código
e chama o método que contém GridSearchCV () em um loop for)
Código:

import sklearn.metrics as metrics
de sklearn.grid_search import GridSearchCV
importar numpy como np
importar os
de conjuntos de dados de importação sklearn
de sklearn importar svm como 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):
para o período em intervalo np.arange (0,100,10):
clf = hyperparam_tuning_method (trainingData, período)

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

importe alguns dados para brincar

iris = datasets.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 e-mail diretamente ou visualize-o em Gi tHubhttps: //github.com/scikit-learn/scikit-learn/issues/2889#issuecomment -35990430
.

(Como um ponto lateral, @ogrisel , noto que parece haver muito mais joblib
sobrecarga de paralelização no mestre - no OS X pelo menos - que não estava lá
em 0,14 ...)

Em 25 de fevereiro de 2014 21:52, Joel Nothman [email protected] :

Geralmente, o multiprocessamento no Windows encontra muitos problemas. Mas eu
não sei por que isso deve ser correlacionado com uma métrica personalizada. Há
nada sobre a opção média = macro em 0,14 que sugira que deveria ser
mais probabilidade de travar do que a média padrão (ponderada). No desenvolvimento
cabeça, isso termina em 11s no meu macbook e em 7s na versão 0.14
(isso é algo para se olhar!)

Você é capaz de experimentar na versão de desenvolvimento atual, para ver se
ainda é um problema?

Em 25 de fevereiro de 2014 20:40, adverley [email protected] escreveu:

Obrigado pela sua resposta rápida.

Com crashing, na verdade quero dizer congelamento. Não continua mais e
também não há mais atividade a ser monitorada no processo python de
gerenciador de tarefas do Windows. Os processos ainda estão lá e consomem um
quantidade constante de RAM, mas não requer tempo de processamento.

Esta é a versão 0.14 do scikit-learn, atualizada pela última vez e executada usando o Enthought
Marquise.

Estou na plataforma "Windows-7-6.1.7601-SP1".

Aprofundarei mais, fornecendo um exemplo genérico do problema.
Acho que tem a ver com o GridSearchCV sendo colocado em um loop for. (Para
não perca muito do seu tempo, você provavelmente deve começar no
método run_tune_process () que está sendo chamado na parte inferior do código
e chama o método que contém GridSearchCV () em um loop for)
Código:

import sklearn.metrics as metrics
de sklearn.grid_search import GridSearchCV
importar numpy como np
importar os
de conjuntos de dados de importação sklearn
de sklearn importar svm como 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):
para o período em intervalo np.arange (0,100,10):
clf = hyperparam_tuning_method (trainingData, período)

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

importe alguns dados para brincar

iris = datasets.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 e-mail diretamente ou visualize-o em Gi tHubhttps: //github.com/scikit-learn/scikit-learn/issues/2889#issuecomment -35990430
.

Isso não tem nada a ver com marcadores personalizados. Este é um recurso bem conhecido do multiprocessamento Python no Windows: você deve executar tudo que usa n_jobs=-1 em um bloco if __name__ == '__main__' ou você travará / travará. Talvez devêssemos documentar isso em algum lugar com destaque, por exemplo, no README?

você tem que executar tudo que usa n_jobs = -1 em um if name ==
bloco ' principal ' ou você obterá travamentos / travamentos.

Bem, a boa notícia é que hoje em dia joblib dá um erro significativo
mensagem em tal acidente, ao invés de uma bomba de fork.

@GaelVaroquaux o

@GaelVaroquaux o
problema pode ser considerado corrigido, IMHO.

Deve servir. A única maneira de ter certeza é verificar. Estou indo bem
agora, e não consigo inicializar uma VM do Windows para fazer isso.

Não vou instalar um compilador C no Windows apenas para isso. Desculpe, mas eu realmente não uso o Windows :)

Não vou instalar um compilador C no Windows apenas para isso. Desculpe, mas eu
realmente não faço o Windows :)

Eu tenho uma VM do Windows. Eu posso checar. É apenas uma questão de encontrar um
pouco tempo para fazê-lo.

@larsmans , você está completamente certo. O objeto scorer customizado foi um erro da minha parte, o problema está mesmo no multiprocessamento no windows. Tentei este mesmo código em um Linux e funciona bem.

Não recebo nenhuma mensagem de erro porque ele não trava, apenas para de fazer qualquer coisa significativa.

@adverley Você poderia tentar a versão mais recente do GitHub em sua caixa do Windows?

Fechando devido à falta de retorno do arquivo e é provavelmente um problema conhecido que foi corrigido no joblib mais recente.

Não tenho certeza se relacionado, parece ser.

No Windows, o marcador personalizado ainda congela. Eu encontrei este tópico no google - removeu o marcador e a pesquisa em grade funciona.

Quando ele congela, não mostra nenhuma mensagem de erro. Existem 3 processos python gerados também (porque eu defini n_jobs = 3). No entanto, a utilização da CPU permanece 0 para todos os processos Python. Estou usando o Notebook IPython.

Você pode compartilhar o código do marcador? Parece um pouco improvável.

Seu marcador usa joblib / n_jobs em algum lugar? Não deveria, e isso pode causar problemas (embora eu ache que o joblib deva detectar isso).

Claro - aqui está o código completo - http://pastebin.com/yUE26SNs

A função do marcador é "score_model", ela não usa joblib.

Isso é executado no prompt de comando, mas não no IPython Notebook. A mensagem de erro é -
AttributeError: Can't get attribute 'score_model' on <module '__main__' (built-in)>;

Em seguida, o IPython e todas as instâncias Python geradas tornam-se inativos - silenciosamente - e não respondem mais a nenhum código Python até que eu reinicie.

Corrija o erro de atributo, então ele funcionará.
Você faz importações de pylab no notebook IPython? Caso contrário, tudo deve ser igual.

Bem, eu não sei o que causa o AttributeError ... Embora seja provavelmente relacionado a joblibs, uma vez que _isso acontece apenas quando n_jobs é maior que 1_, funciona bem com n_jobs=1 .

O erro fala sobre o atributo score_model ausente em __main__ , se eu tenho ou não um if __name__ == '__main__' no Notebook IPython.

(Percebi que a linha de erro foi colada incorretamente acima - eu editei no post acima.)

Eu não uso pylab.

Aqui está a mensagem de erro estendida completa - http://pastebin.com/23y5uHT2

Hum, isso provavelmente está relacionado a problemas de multiprocessamento no Windows. Talvez @GaelVaroquaux ou @ogrisel possam ajudar.
Não sei o que o caderno faz de __name__ == "__main__" .
Tente não definir a métrica no notebook, mas em um arquivo separado e importe-o. Eu acho que isso resolveria isso.
Isso não está realmente relacionado ao GridSearchCV, mas a alguma interação interessante entre o multiprocessamento do Windows, notebook IPython e joblib.

pessoal ... obrigado pelo tópico. De qualquer forma, eu deveria ter verificado este tópico antes, perdi 5 horas do meu tempo nisso. Tentando executar em processamento paralelo. Muito obrigado :)
PARA ADICIONAR UM FEEDBACK: ainda está congelando. Eu enfrentei o mesmo problema quando na presença de minha própria função de custo make_Score ... meu sistema começa a congelar. Quando eu não usei a função de custo personalizada, não enfrentei esses congelamentos no processamento paralelo

A melhor maneira de transformar essas 5 horas em algo útil para o projeto, seria nos fornecer um exemplo autônomo reproduzindo o problema.

Eu estava tendo o mesmo problema no Windows 10, trabalhando no notebook Jupyter, tentando usar um marcador personalizado em uma validação cruzada aninhada e n_jobs = -1. Eu estava recebendo a mensagem AttributeError: Can't get attribute 'custom_scorer' on <module '__main__' (built-in)>; .
Como @amueller sugeriu, importar o marcador personalizado em vez de defini-lo no bloco de notas funciona.

Eu tenho exatamente o mesmo problema no OSX 10.10.5

Mesmo aqui.
OSX 10.12.5

Forneça um snippet de código reproduzível. Adoraríamos chegar ao fundo disso. É difícil entender sem código, incluindo dados, que nos mostra o problema.

Basta executar essas linhas em um shell 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)

Observe que remover a etapa PCA do pipeline resolve o problema.

Mais informações:

Darwin-16.6.0-x86_64-i386-64bit
('Python', '2.7.13 (padrão, 4 de abril de 2017, 08:47:57) \ n [GCC 4.2.1 compatível com Apple LLVM 8.1.0 (clang-802.0.38)]')
('NumPy', '1.12.1')
('SciPy', '0.19.1')
('Scikit-Learn', '0.18.2')

visto que você não usa um marcador personalizado, devemos assumir que é um
questão separada?

Em 8 de agosto de 2017, 18h15, "boazsh" [email protected] escreveu:

Basta executar essas linhas em um shell python

from sklearn.decomposition import PCAfrom sklearn.svm import SVCfrom sklearn.preprocessing import RobustScalerfrom sklearn.metrics importar rating_reportfrom sklearn.pipeline import Pipelinefrom sklearn.model_selection import cross_val_predict

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) imprimir classificação_report (Y, previsões)

Observe que remover a etapa PCA do pipeline resolve o problema.

Mais informações:

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

-
Você está recebendo isso porque comentou.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment-320885103 ,
ou silenciar o tópico
https://github.com/notifications/unsubscribe-auth/AAEz6-6Klhc67b5kZ17fFTxc8RfZQ_BWks5sWBkLgaJpZM4BkiD9
.

Quando enfrentei esse problema pela primeira vez, estava usando o pontuador personalizado, mas ao tentar simplificar o código de exemplo o máximo possível, descobri que ele não precisa necessariamente conter o pontuador personalizado. Pelo menos na minha máquina. Importar o marcador também não ajudou no meu caso. De qualquer forma, os sintomas são semelhantes. O script trava para sempre e a utilização da CPU é baixa.

@boazsh muito obrigado pelo snippet, embora não seja determinístico, você pode editá-lo e usar um np.random.RandomState para garantir que os números aleatórios sejam sempre os mesmos em cada execução.

Também há uma solução alternativa se você estiver usando o Python 3 sugerido, por exemplo, em https://github.com/scikit-learn/scikit-learn/issues/5115#issuecomment -187683383.

Não tenho como testar isso no OSX no momento, mas posso tentar nos próximos dias.

Algumas informações úteis (basta adicionar o que está faltando em seu comentário 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__)

Além disso, como você instalou o scikit-learn, com pip, com conda, com um dos gerenciadores de pacotes OSX (brew, etc ...)?

Atualizado o snippet (usado np.random.seed)

Darwin-16.6.0-x86_64-i386-64bit
('Python', '2.7.13 (padrão, 4 de abril de 2017, 08:47:57) \ n [GCC 4.2.1 compatível com Apple LLVM 8.1.0 (clang-802.0.38)]')
('NumPy', '1.12.1')
('SciPy', '0.19.1')
('Scikit-Learn', '0.18.2')

Atualizado o snippet (usado np.random.seed)

Muito obrigado!

Além disso, como você instalou o scikit-learn, com pip, com conda, com um dos gerenciadores de pacotes OSX (brew, etc ...)?

Você já respondeu esta, não consigo encontrar sua resposta ...

Desculpe, perdi - pip.

FWIW, não tenho problemas para executar esse snippet com:

plataforma de importação; imprimir (platform.platform ())
Darwin-16.7.0-x86_64-i386-64bit
import sys; print ("Python", sys.version)
Python 2.7.12 | Continuum Analytics, Inc. | (padrão, 2 de julho de 2016, 17:43:17)
[GCC 4.2.1 (baseado na Apple Inc. build 5658) (LLVM build 2336.11.00)]
import numpy; imprimir ("NumPy", numpy .__ version__)
NumPy 1.13.1
import scipy; imprimir ("SciPy", scipy .__ versão__)
SciPy 0.19.1
importar sklearn; imprimir ("Scikit-Learn", sklearn .__ version__)
Scikit-Learn 0.18.2

Você poderia colocar verbose = 10 em cross_val_predict também, para que possamos talvez
vê onde quebra para você?

Em 8 de agosto de 2017 às 22:59, boazsh [email protected] escreveu:

Desculpe, perdi - pip.

-
Você está recebendo isso porque comentou.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment-320948362 ,
ou silenciar o tópico
https://github.com/notifications/unsubscribe-auth/AAEz67S64KIXUGvARGjvxBOw_4aCAdqhks5sWFu0gaJpZM4BkiD9
.

@jnothman Estou supondo que seu ambiente conda usa MKL e não Accelerate. Este problema de congelamento é específico para o multiprocessamento Accelerate e Python. http://scikit-learn.org/stable/faq.html#why -do-i-something-get-a-crash-freeze-with-n-jobs-1-under-osx-or-linux para mais detalhes .

pip, por outro lado, usará rodas que são enviadas com o Accelerate (no momento da escrita).

Uma alternativa (diferente de JOBLIB_START_METHOD) para evitar esse bug em particular é usar MKL (por exemplo, via conda) ou OpenBLAS (por exemplo, via canal conda-forge).

Nada está sendo impresso ...

@jnothman Estou supondo que seu ambiente conda usa MKL e não Accelerate.

@jnothman caso você queira reproduzir o problema, IIRC você pode criar um ambiente com o Accelerate no OSX com algo como:

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

FWIW Não consigo reproduzir o problema no meu OS X VM. Tentei imitar o mais próximo possível as versões 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, na verdade eu posso reproduzir, mas seu trecho não foi um reprodutor completo. Aqui está um snippet atualizado:

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))

Em qualquer caso, este é um problema conhecido com o multiprocessamento Accelerate e Python. Soluções alternativas existem e foram listadas em postagens anteriores. O mais fácil é provavelmente usar o conda e certifique-se de usar o MKL e não o Accelerate.

No longo prazo (provavelmente scikit-learn 0.20), este problema será resolvido universalmente pelo novo back-end loky para joblib: https://github.com/scikit-learn/scikit-learn/issues/7650

Ter uma correção para multiprocessamento dependente da versão scikit-learn é um sintoma dos problemas de venda ....

Ter uma correção para multiprocessamento dependente da versão scikit-learn é um sintoma dos problemas de venda ....

Recentemente li o seguinte, que achei interessante:
https://lwn.net/Articles/730630/rss

Tenho um problema semelhante com RandomizedSearchCV; ele trava indefinidamente. Estou usando um macbook pro de 3 anos, 16 GB de ram e core i7, e minha versão do scikit-learn é 0,19.

A parte intrigante é que estava funcionando na sexta-feira passada !!! Segunda de manhã, eu volto e tento correr e simplesmente congela. Sei de execuções anteriores que demorou cerca de 60 minutos para terminar, mas esperei muito mais do que isso e nada acontece, ele apenas trava, sem mensagens de erro, nada e meu computador esquenta e suga energia como se não houvesse amanhã. Código abaixo. Tentei mudar n_iter para 2 e n_jobs = 1 depois de ler alguns comentários aqui e funcionou. Portanto, pode ter algo a ver com n_jobs = -1. Ainda assim, este código funcionou bem na última sexta-feira! simplesmente odeia segundas-feiras. O tamanho do meu conjunto de dados é inferior a 20k exemplos com dimensionalidade <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

o que é crf? apenas para eliminar a possibilidade, você poderia tentar usar
return_train_score = False?

É muito provável que o problema do @KaisJM seja devido à conhecida limitação do Accelerate with multiprocessing, veja nosso faq .

Como você instalou o scikit-learn?

Também para referência futura, você pode colar a saída 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__)

isso estava funcionando na última sexta-feira !! Não fiz nada desde então. Eu acho que o scikit learn faz parte do anaconda, mas eu atualizei com o pip (pip install --upgrade sklearn), mas isso foi antes de eu ter esse problema .. Eu executei o código corretamente depois de atualizar para 0.19.

aqui está o resultado das impressões acima:

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 : Estou usando RandomizedSearchCV de sklearn.grid_search que não tem o parâmetro return_train_score. Eu sei que sklearn.grid_search está obsoleto. Vou tentar o de sklearn.model_selection, mas algo me diz que terei exatamente o mesmo problema). Comentário original atualizado com mais informações e código.

Você pode postar a saída de conda list | grep numpy . Eu poderia supor que, ao atualizar o scikit-learn com o pip, você atualizou o numpy com o pip também e obteve as rodas numpy que usam o Accelerate e tem a limitação mencionada acima.

Pequeno conselho:

• postar um trecho totalmente autônomo (para sua próxima edição). Isso significa que qualquer um pode copiar e colar em uma sessão IPython e tentar reproduzi-lo facilmente. Isso lhe dará a melhor chance de obter um bom feedback.
• se você estiver usando o conda, use o conda para gerenciar os pacotes disponíveis por meio do conda. Use pip apenas quando for necessário.
• Se você insiste que deseja usar pip install --update , eu recomendo fortemente que você use pip install --update --no-deps . Caso contrário, se um pacote depender, digamos, de numpy, e acontecer de você não ter o último numpy, numpy será atualizado com pip, o que você não quer.

Ah, sim e BTW, sklearn.grid_search está obsoleto, você provavelmente deseja usar sklearn.model_selection em um ponto não muito distante.

Bom conselho, obrigado. Então, é a solução alternativa para fazer o downgrade do numpy? a que limitação você está se referindo? o link de FAQ acima? Eu li, mas não entendo essas coisas (sou apenas um cara de algo :)).

saída de conda list | grep numpy

numpy 1.12.0
numpy 1.12.0 py27_0
entorpecido 1.13.1
numpydoc 0.7.0

Uau três numpy instalado Eu vi dois antes, mas nunca três ... de qualquer forma isso parece um indicativo do problema que eu estava mencionando, ou seja, você misturou pip e conda, o que é uma má ideia para um determinado pacote.

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

Esperançosamente depois disso você terá um único numpy que usa MKL.

Se eu fosse você, voltaria a verificar se você não tem o mesmo problema para outros pacotes científicos básicos, por exemplo, scipy, etc ...

o motivo pelo qual recorro ao pip para alguns pacotes é que conda não tem alguns pacotes, o que na verdade é muito frustrante, porque sei que misturar pip com conda é uma má ideia. Na próxima vez que isso acontecer, usarei a opção --no-deps.

uma coisa que deveria ter mencionado é que instalei o Spyder dentro do ambiente python em que estava trabalhando. No entanto, consegui executar o código depois de instalar o Spyder, tanto no Spyder quanto no Jupyter.

Desinstalei o Spyder e os numpys acima, reinstalei o bumpy com conda (que atualizou o scikit para 0,19) e ainda recebo o mesmo erro. Algo pode ter acontecido por causa da instalação do Spyder, mas então por que funcionaria por um dia e então pararia repentinamente?

ok, nada está funcionando !! devo apenas criar um novo ambiente (usando conda) e reinstalar tudo lá? isso vai resolver ou piorar?

Parece que vale a pena tentar!

criou um novo env e instalei tudo com conda, ainda congela indefinidamente. apenas uma cópia de cada pacote etc.

n_jobs = 1 funciona, mas leva uma eternidade, é claro (funcionou no env anterior também). n_jobs = -1 é o que 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')

Então eu não sei. A única maneira de investigarmos é postar um snippet totalmente autônomo que podemos simplesmente copiar e colar em uma sessão IPython e ver se podemos reproduzir o problema.

tentará criar um exemplo mínimo que reproduza o problema. Preciso fazer isso para depurar com mais eficiência.

Eu li a entrada do FAQ que você mencionou sobre "Acelerar" .. não é de muita ajuda para mim. O que eu deduzi disso é que a chamada a fork () NOT seguida por exec () é ruim. Eu pesquisei no Google sobre isso e nada até agora sugere uma solução alternativa. Você pode apontar mais algumas informações, mais detalhes sobre qual é o problema? obrigado,

Experimente este snippet (retirado 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))

• Se isso congelar (ou seja, não terminar em um segundo), significa que você está usando o Accelerate e o congelamento é uma limitação conhecida do multiprocessamento Python. A solução alternativa é não usar o Accelerate. No OSX, você pode fazer isso com o conda, que usa MKL por padrão. Você também pode usar o OpenBLAS usando o conda-forge.
• Se ele não congelar, você não está usando o Accelerate e precisaríamos de um snippet independente para investigar.

tentará reproduzir com o mínimo de código.

Without multiprocessing:
Enter
Exit

With multiprocessing:
Enter
Exit
Enter
Exit

@GaelVaroquaux scikit -learn não é um aplicativo, mas uma biblioteca em um rico ecossistema. Se todos fizessem o que fazemos, tudo desabaria. Esse é um sinal bastante claro de que precisamos mudar. E há muitos ambientes onde o oposto desse comentário é verdadeiro.

Eu usei uma instância virtual ubuntu no google cloud compute engine (bumpy, picante, scikit etc não eram os mais atualizados). O código funcionou bem. Então instalei o Gensim. Este numpy e scipy atualizado para as versões mais recentes e instalou algumas outras coisas de que precisa (boto, bz2file e smart_open). Depois disso, o código congela. Espero que isso dê uma pista útil sobre o que causa esse congelamento.

depois de instalar o Gensim
numpy (1.10.4) atualizado para numpy (1.13.3)
scipy (0.16.1) atualizado para scipy (0.19.1)

mais informações:
Fazendo algumas pesquisas descobri que libblas, liblapack e liblapack_atlas estavam faltando em meu / usr / lib /, também não encontrei o diretório / usr / lib / atlas-base /. Não sei se eles estavam lá e a instalação do gensim os removeu, pois atualizou o numpy etc, mas isso é provável, pois o código funcionou antes de instalar o gensim. Eu os instalei usando sudo apt-get --yes install libatlas-base-dev e "_update-alternativas_" de acordo com as instruções de instalação avançada do scikit, mas não ajudou, o código ainda congela com n_jobs = -1.

Acho que o problema é que o numpy está usando o OpenBlas. Vou mudar para ATLAS e ver o que acontece.

>>> 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

Ainda é o mesmo problema. O seguinte funciona bem, a menos que eu insira 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 suas instalações Numpy e Scipy usam ATLAS ou OpenBLAS?

É um pouco difícil seguir o que você fez @KaisJM. Do ponto de vista do mantenedor, o que precisamos é de um snippet python totalmente autônomo para ver se podemos reproduzi-lo. Se pudermos reproduzir, só então poderemos investigar e tentar entender o que está acontecendo. Se isso só acontecer quando você instalar o gensim e conseguir reproduzir esse comportamento de forma consistente, precisaríamos de instruções completas sobre como criar um ambiente Python que tem o problema versus um ambiente Python que não tem o problema.

Isso requer uma quantidade não desprezível de tempo e esforço, concordo totalmente, mas sem isso, infelizmente, não há muito que possamos fazer para investigar o problema que você está enfrentando.

de acordo com as instruções de instalação avançadas

@KaisJM aliás, esta página está desatualizada, já que hoje em dia as rodas estão disponíveis no Linux e contêm seu próprio OpenBLAS. Se você instalar um scikit-learn lançado com pip, usará o OpenBLAS.

@lesteve, você está dizendo que o Openblas não causa mais um congelamento?

@lesteve paula postou um snippet que também tem o mesmo problema. Posso ver que não é um código completo, mas espero que dê alguma pista. Posso fazer aqui um trecho "completo" e postar para você. No entanto, é claro que a página de instruções "desatualizada" - como você a chama - pode não estar tão desatualizada. A maior probabilidade é que o OpenBLAS esteja causando as taxas de que estão falando naquela página.

Estas instruções estão desatualizadas, acredite em mim. Se você ler em detalhes, diz "mas pode congelar joblib / multiprocessamento antes do OpenBLAS versão 0.2.8-4". Eu verifiquei uma roda numpy recente e ela contém OpenBLAS 0.2.8.18. O congelamento a que eles se referem é aquele em https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment -334155175, que você não parece ter.

Posso ver que não é um código completo, mas espero que dê alguma pista

Não, realmente não. Temos relatos de usuários que parecem indicar que o congelamento ainda pode acontecer, nenhum dos quais conseguimos reproduzir AFAIK. Isso parece indicar que esse problema ocorre em alguma combinação muito específica de fatores. A menos que alguém que tenha o problema gaste algum tempo e descubra como reproduzir de forma controlada e nós consigamos reproduzir, não há como fazer nada a respeito.

Eu posso fazer aqui um trecho "completo" e postar para você

Isso seria bom. Isso seria ótimo se você pudesse verificar se esse snippet ainda causa o congelamento em um ambiente conda separado (ou virtualenv, dependendo do que você usa).

@lesteve @paulaceccon : Peguei o código do trecho de Paula e fiz um trecho de código completo e

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 Eu acho que é mais útil se você começar a partir do seu script de congelamento e conseguir simplificar e postar um totalmente autônomo que congela para você.

@lesteve Concordo. Eu criei um novo ambiente python2 como o que eu tinha antes de instalar o Gensim. O código funcionou bem, NÃO congelou com n_jobs = -1. Além do mais, o Numpy está usando OpenBLAS e tem a mesma configuração do ambiente que exibe o congelamento (aquele onde o Gensim foi instalado). Portanto, parece que o openblas não é a causa desse congelamento.

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 Estou executando o mesmo snippet aqui (windows) e ele 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_)

Eu sei que é estranho, mas não congelou ao ser executado com uma métrica _custom_.

Eu tenho um problema similar. Estou executando o mesmo código e simplesmente queria atualizar o modelo com os novos dados do mês e ele parou de funcionar. eu acredito que sklearn foi atualizado nesse meio tempo para 0,19

Executar GridSearchCV ou RandomizedSearchCV em um loop e n_jobs> 1 travaria silenciosamente no Jupiter & 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)

    ...

Seguiu a recomendação @lesteve e verificou o ambiente e removeu o numpy instalado com pip:

Darwin-16.6.0-x86_64-i386-64bit
Python 3.6.1 | Anaconda customizado (x86_64) | (padrão, 11 de maio de 2017, 13:04:09)
[GCC 4.2.1 compatível com Apple LLVM 6.0 (clang-600.0.57)]
NumPy 1.13.1
SciPy 0.19.1
Scikit-Learn 0.19.0

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

$ pip uninstall numpy

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

$ conda install numpy -f // provavelmente desnecessário

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

Resolvido meu problema.

@paulaceccon seu problema está relacionado a

https://stackoverflow.com/questions/36533134/cant-get-attribute-abc-on-module-main-from-abc-h-py
Se você declarar o pool antes de declarar a função que está tentando usar em paralelo, esse erro será gerado. Inverta a ordem e ele não gerará mais esse erro.

O seguinte irá executar o seu 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_)

com 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 rodando em 8 núcleos

Ajustando 3 dobras para cada um dos 54 candidatos, totalizando 162 ajustes
{'class_weight': {0: 0.51891309, 1: 13.71835531}, 'criterion': 'gini', 'min_samples_leaf': 10, 'min_samples_split': 20, 'n_estimators': 400}

O problema ainda está aí, pessoal. Estou usando um marcador personalizado e ele continua indefinidamente quando eu defino n_jobs como qualquer coisa. Quando eu não especifico n_jobs, ele funciona bem, mas congela.

Você pode fornecer um snippet autônomo para reproduzir o problema? Leia https://stackoverflow.com/help/mcve para mais detalhes.

Ainda enfrentando esse problema com o mesmo código de exemplo.

Windows-10-10.0.15063-SP0
Python 3.6.4 | Anaconda customizado (64 bits) | (padrão, 16 de janeiro de 2018, 10:22:32) [MSC v.1900 64 bits (AMD64)]
NumPy 1.14.1
SciPy 1.0.0
Scikit-Learn 0.19.1

Você pode fornecer um snippet autônomo para reproduzir o problema? Leia https://stackoverflow.com/help/mcve para mais detalhes.

Eu suspeito que este é o mesmo velho problema de multiprocessamento do Windows. veja nosso FAQ

Testei o código em https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment -337985212 de thomberg1.

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

Funcionou bem no Notebook Jupyter e na linha de comando.

HI, estou tendo o mesmo problema, então eu não queria abrir um novo que poderia levar a um tópico quase 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))

O código é de um tutorial: https://machinelearningmastery.com/use-keras-deep-learning-models-scikit-learn-python/
Tentei alterar o parâmetro n_jobs para 1, -1, mas nenhum deles funcionou. Alguma dica?

ele é executado se eu adicionar a importação de multiprocessamento e a instrução if como mostrado abaixo - eu não trabalho com keras, então não tenho mais insight

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))

Encaixe 3 dobras para cada um dos 18 candidatos, totalizando 54 ajustes

Melhor: 0,675781 usando {'batch_size': 5, 'epochs': 5, 'init': 'glorot_uniform', 'otimizador': 'adam'}
0,621094 (0,036225) com: {'batch_size': 5, 'epochs': 5, 'init': 'glorot_uniform', 'otimizador': 'rmsprop'}
0,675781 (0,006379) com: {'batch_size': 5, 'epochs': 5, 'init': 'glorot_uniform', 'otimizador': 'adam'}
...
0,651042 (0,025780) com: {'batch_size': 20, 'epochs': 5, 'init': 'uniforme', 'otimizador': 'adam'}

informação da versão se necessário
sys 3.6.4 | Anaconda customizado (64 bits) | (padrão, 16 de janeiro de 2018, 12:04:33)
[GCC 4.2.1 Compatible Clang 4.0.1 (tags / RELEASE_401 / final)]
entorpecido 1.14.2
pandas 0.22.0
sklearn 0.19.1
tocha 0.4.0a0 + 9692519
IPython 6.2.1
keras 2.1.5

compilador: GCC 4.2.1 Compatible Clang 4.0.1 (tags / RELEASE_401 / final)
sistema: Darwin
lançamento: 17.5.0
máquina: x86_64
processador: i386
Núcleos da CPU: 24
intérprete: 64 bits

Obrigado @ thomberg1 , mas adicionando

import multiprocessing
if __name__ == '__main__':

não ajudou. O problema ainda é o mesmo

O mesmo problema em minha máquina ao usar a função de pontuação personalizada em GridsearchCV .
python 3.6.4,
scikit-learn 0.19.1,
windows 10.,
Núcleos da CPU: 24

@byrony você pode fornecer código para reproduzir? você usou if __name__ == "__main__" ?

Eu experimentei um problema semelhante várias vezes em minha máquina ao usar n_jobs=-1 ou n_jobs=8 como um argumento para GridsearchCV mas usando o argumento de artilheiro padrão.

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

Aqui está o código que usei:

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()

Eu sei que é um grande conjunto de dados, então esperava que levasse algum tempo para obter resultados, mas depois de 2 dias de execução, ele simplesmente parou de funcionar (o script continua em execução, mas não está usando nenhum recurso além de RAM e swap).

Desde já, obrigado!

@amueller Eu não usei if __name__ == "__main__" . Abaixo está o meu código, ele só funciona quando 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)

Você está usando o XGBoost. Não sei o que eles fazem internamente, é bem possível que seja esse o problema. Você pode tentar ver se adicionar if __name__ ajuda?
Caso contrário, não acho que haja uma solução para isso ainda.

@ Pazitos10 você pode reproduzir com dados sintéticos e / ou dados menores? Não consigo reproduzir sem seus dados e seria bom reproduzir em menos tempo.

@amueller Ok, irei executá-lo novamente com

@amueller , a execução do script com 50k linhas funciona conforme o esperado. O script termina corretamente, mostrando os resultados da seguinte forma (desculpe, eu quis dizer 50k, não 500k):

O problema é que não sei se esses resultados serão os melhores para todo o meu conjunto de dados. Algum conselho?

Parece que você está ficando sem memória RAM. Em vez disso, tente usar o Keras, provavelmente é a melhor solução para redes neurais de grande escala.

@amueller Oh, ok. Em vez disso, tentarei usar o Keras. Obrigado de novo!

Isso não tem nada a ver com marcadores personalizados. Este é um recurso bem conhecido do multiprocessamento Python no Windows: você deve executar tudo que usa n_jobs=-1 em um bloco if __name__ == '__main__' ou você travará / travará. Talvez devêssemos documentar isso em algum lugar com destaque, por exemplo, no README?

É talvez uma ideia para o scikit, que no caso do Windows alterar a função
E use filas para alimentar tarefas para uma coleção de processos de trabalho e coletar os resultados
Conforme descrito aqui: https://docs.python.org/2/library/multiprocessing.html#windows
e para 3.6 aqui: https://docs.python.org/3.6/library/multiprocessing.html#windows

@PGTBoos, isso foi corrigido no scikit-learn 0.20.0