यह आश्चर्यजनक है, इसलिए हमें यह पता लगाना होगा कि समस्या क्या है और सुनिश्चित करें कि यह काम करती है!

क्या आप कृपया थोड़ा और विवरण प्रदान कर सकते हैं:

• "दुर्घटनाओं" से आपका क्या मतलब है?
• यह स्किकिट-लर्न का कौन सा संस्करण है? यदि यह 0.14 है, तो क्या यह अभी भी वर्तमान विकास संस्करण में होता है?
• मल्टीप्रोसेसिंग में प्लेटफ़ॉर्म-विशिष्ट समस्याएं हैं। आप किस प्लेटफॉर्म पर हैं? (जैसे import platform; platform.platform() )
• क्या आपने इसे विभिन्न डेटासेट पर आजमाया है?

एफडब्ल्यूआईडब्ल्यू, मेरी मशीन को स्केलेर के विकास संस्करण पर इस स्निपेट के साथ आईरिस फिट करने में कोई समस्या नहीं है।

धन्यवाद आपके शीघ्र प्रतिउत्तर के लिए।

दुर्घटनाग्रस्त होने से मेरा वास्तव में मतलब ठंड से है। यह अब और जारी नहीं है और विंडोज़ के टास्क मैनेजर की पायथन प्रक्रिया में निगरानी के लिए और कोई गतिविधि नहीं है। प्रक्रियाएं अभी भी हैं और रैम की निरंतर मात्रा का उपभोग करती हैं लेकिन प्रसंस्करण समय की आवश्यकता नहीं होती है।

यह स्किकिट-लर्न वर्जन 0.14 है, जिसे अंतिम बार एनथॉट कैनोपी का उपयोग करके अपडेट किया गया और चलाया गया।

मैं प्लेटफॉर्म "विंडोज-7-6.1.7601-एसपी1" पर हूं।

मैं समस्या का एक सामान्य उदाहरण प्रदान करके गहराई में जाऊंगा। मुझे लगता है कि इसे ग्रिडसर्चसीवी को लूप में रखा जाना है। (अपना अधिक समय बर्बाद न करने के लिए, आपको शायद रन_ट्यून_प्रोसेस() विधि से शुरू करना चाहिए जिसे कोड के नीचे बुलाया जा रहा है और लूप में ग्रिडसर्चसीवी() युक्त विधि को कॉल करता है)

कोड:

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)

एक बार फिर, यह कोड मेरे कंप्यूटर पर तभी काम करता है जब मैं n_jobs को 1 में बदलता हूं या जब मैं स्कोरिंग = तर्क को परिभाषित नहीं करता हूं।

विंडोज़ में आम तौर पर मल्टीप्रोसेसिंग में बहुत सी समस्याएं आती हैं। लेकिन मैं
पता नहीं क्यों इसे एक कस्टम मीट्रिक के साथ सहसंबद्ध किया जाना चाहिए। वहाँ है
0.14 में औसत = मैक्रो विकल्प के बारे में कुछ भी नहीं है जो बताता है कि यह होना चाहिए
डिफ़ॉल्ट औसत (भारित) से लटकने की अधिक संभावना है। विकास पर
सिर, यह मेरी मैकबुक पर 11s में पूरा होता है, और 7s में संस्करण 0.14 . पर पूरा होता है
(यह देखने के लिए कुछ है!)

क्या आप इसे वर्तमान विकास संस्करण में आज़मा सकते हैं, यह देखने के लिए कि क्या
यह अभी भी एक मुद्दा है?

२५ फरवरी २०१४ को २०:४० को, एडवरली नोटिफिकेशन @github.com ने लिखा:

धन्यवाद आपके शीघ्र प्रतिउत्तर के लिए।

दुर्घटनाग्रस्त होने से मेरा वास्तव में मतलब ठंड से है। यह अब और जारी नहीं है
की अजगर प्रक्रिया में निगरानी के लिए कोई और गतिविधि भी नहीं है
विंडोज़ के कार्य प्रबंधक। प्रक्रियाएं अभी भी हैं और उपभोग करें a
RAM की निरंतर मात्रा लेकिन प्रसंस्करण समय की आवश्यकता नहीं है।

यह स्किकिट-लर्न वर्जन 0.14 है, जिसे अंतिम बार एनथॉट का उपयोग करके अपडेट किया गया और चलाया गया
चंदवा।

मैं प्लेटफॉर्म "विंडोज-7-6.1.7601-एसपी1" पर हूं।

मैं समस्या का एक सामान्य उदाहरण प्रदान करके गहराई में जाऊंगा। मैं
लगता है कि इसे ग्रिडसर्चसीवी को लूप में रखा जाना है। (प्रति
अपना बहुत अधिक समय बर्बाद न करें, आपको शायद शुरू करना चाहिए
run_tune_process() विधि जिसे कोड के नीचे बुलाया जा रहा है
और लूप में GridSearchCV() युक्त विधि को कॉल करता है)
कोड:

sklearn.metrics को मीट्रिक के रूप में आयात करें
sklearn.grid_search से आयात GridSearchCV
np . के रूप में numpy आयात करें
आयात ओएस
स्केलेर आयात डेटासेट से
sklearn आयात svm से sk . के रूप में

def ट्यून_हाइपरपैरामीटर (प्रशिक्षणडेटा, अवधि):
ऑलडाटाट्रेन = ट्रेनिंगडाटा

# 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):
अवधि के लिए np.arange(0,100,10) में:
clf = hyperparam_tuning_method (प्रशिक्षण डेटा, अवधि)

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

खेलने के लिए कुछ डेटा आयात करें

आईरिस = डेटासेट। लोड_आईरिस ()
X_training = आईरिस.डेटा [0:100,:]
Y_training = (iris.target[0:100]).reshape(100,1)
ट्रेनिंगसेट = np.hstack ((Y_training, X_training))

X_test = आईरिस.डेटा [१००:१५०,:]
Y_test = (आईरिस.टारगेट[१००:१५०]).reshape(५०,१)
टेस्टसेट = np.hstack ((Y_test, X_test))

run_tune_process(tune_hyperparameters,trainingset,testset)

इस ईमेल का सीधे उत्तर दें या इसे Gi tHub पर देखेंhttps://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment -35990430
.

(एक साइड पॉइंट के रूप में, @ogrisel , मुझे लगता है कि बहुत अधिक जॉबलिब लगता है)
मास्टर में समांतरता ओवरहेड - ओएस एक्स पर कम से कम - वह वहां नहीं था
0.14 में...)

25 फरवरी 2014 21:52 को, जोएल नोथमैन [email protected] लिखा :

विंडोज़ में आम तौर पर मल्टीप्रोसेसिंग में बहुत सी समस्याएं आती हैं। लेकिन मैं
पता नहीं क्यों इसे एक कस्टम मीट्रिक के साथ सहसंबद्ध किया जाना चाहिए। वहाँ है
0.14 में औसत = मैक्रो विकल्प के बारे में कुछ भी नहीं है जो बताता है कि यह होना चाहिए
डिफ़ॉल्ट औसत (भारित) से लटकने की अधिक संभावना है। विकास पर
सिर, यह मेरी मैकबुक पर 11s में पूरा होता है, और 7s में संस्करण 0.14 . पर पूरा होता है
(यह देखने के लिए कुछ है!)

क्या आप इसे वर्तमान विकास संस्करण में आज़मा सकते हैं, यह देखने के लिए कि क्या
यह अभी भी एक मुद्दा है?

२५ फरवरी २०१४ को २०:४० को, एडवरली नोटिफिकेशन @github.com ने लिखा:

धन्यवाद आपके शीघ्र प्रतिउत्तर के लिए।

दुर्घटनाग्रस्त होने से मेरा वास्तव में मतलब ठंड से है। यह अब और जारी नहीं है
की अजगर प्रक्रिया में निगरानी के लिए कोई और गतिविधि भी नहीं है
विंडोज़ के कार्य प्रबंधक। प्रक्रियाएं अभी भी हैं और उपभोग करें a
RAM की निरंतर मात्रा लेकिन प्रसंस्करण समय की आवश्यकता नहीं है।

यह स्किकिट-लर्न वर्जन 0.14 है, जिसे अंतिम बार एनथॉट का उपयोग करके अपडेट किया गया और चलाया गया
चंदवा।

मैं प्लेटफॉर्म "विंडोज-7-6.1.7601-एसपी1" पर हूं।

मैं समस्या का एक सामान्य उदाहरण प्रदान करके गहराई में जाऊंगा।
मुझे लगता है कि इसे ग्रिडसर्चसीवी को लूप में रखा जाना है। (प्रति
अपना बहुत अधिक समय बर्बाद न करें, आपको शायद शुरू करना चाहिए
run_tune_process() विधि जिसे कोड के नीचे बुलाया जा रहा है
और लूप में GridSearchCV() युक्त विधि को कॉल करता है)
कोड:

sklearn.metrics को मीट्रिक के रूप में आयात करें
sklearn.grid_search से आयात GridSearchCV
np . के रूप में numpy आयात करें
आयात ओएस
स्केलेर आयात डेटासेट से
sklearn आयात svm से sk . के रूप में

def ट्यून_हाइपरपैरामीटर (प्रशिक्षणडेटा, अवधि):
ऑलडाटाट्रेन = ट्रेनिंगडाटा

# 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):
अवधि के लिए np.arange(0,100,10) में:
clf = hyperparam_tuning_method (प्रशिक्षण डेटा, अवधि)

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

खेलने के लिए कुछ डेटा आयात करें

आईरिस = डेटासेट। लोड_आईरिस ()
X_training = आईरिस.डेटा [0:100,:]
Y_training = (iris.target[0:100]).reshape(100,1)
ट्रेनिंगसेट = np.hstack ((Y_training, X_training))

X_test = आईरिस.डेटा [१००:१५०,:]
Y_test = (आईरिस.टारगेट[१००:१५०]).reshape(५०,१)
टेस्टसेट = np.hstack ((Y_test, X_test))

run_tune_process(tune_hyperparameters,trainingset,testset)

इस ईमेल का सीधे उत्तर दें या इसे Gi tHub पर देखेंhttps://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment -35990430
.

इसका कस्टम स्कोरर से कोई लेना-देना नहीं है। यह विंडोज़ पर पायथन मल्टीप्रोसेसिंग की एक प्रसिद्ध विशेषता है: आपको n_jobs=-1 का उपयोग करने वाली हर चीज को if __name__ == '__main__' ब्लॉक में चलाना होगा या आपको फ्रीज/क्रैश मिलेगा। हो सकता है कि हमें इसे कहीं प्रमुख रूप से दस्तावेज करना चाहिए, उदाहरण के लिए रीडमे में?

आपको वह सब कुछ चलाना होगा जो n_jobs= -1 का उपयोग करता है अगर नाम == . में
' मुख्य ' ब्लॉक या आपको फ़्रीज़/क्रैश मिलेंगे।

खैर, अच्छी खबर यह है कि आजकल जॉबलिब एक सार्थक त्रुटि देता है
फोर्क बम के बजाय ऐसी दुर्घटना पर संदेश।

@GaelVaroquaux क्या वर्तमान विज्ञान-सीखना उस त्रुटि संदेश को देता है? यदि ऐसा है, तो समस्या को ठीक किया जा सकता है, IMHO।

@GaelVaroquaux क्या वर्तमान विज्ञान-सीखना उस त्रुटि संदेश को देता है? यदि हां, तो
मुद्दा तय माना जा सकता है, IMHO।

यह करना चाहिए। सुनिश्चित करने का एकमात्र तरीका जांचना है। मैं सही चल रहा हूँ
अभी, और मैं ऐसा करने के लिए Windows VM को बूट नहीं कर सकता।

मैं सिर्फ इसके लिए विंडोज़ पर सी कंपाइलर स्थापित नहीं करने जा रहा हूं। क्षमा करें, लेकिन मैं वास्तव में विंडोज़ नहीं करता :)

मैं सिर्फ इसके लिए विंडोज़ पर सी कंपाइलर स्थापित नहीं करने जा रहा हूं। क्षमा करें, लेकिन मैं
वास्तव में विंडोज़ मत करो :)

मेरे पास एक विंडोज वीएम है। मैं जाँच कर सकता हूँ। यह सिर्फ एक खोजने का सवाल है
करने के लिए थोड़ा समय है।

@ लार्समैन , आप बिल्कुल सही हैं। कस्टम स्कोरर ऑब्जेक्ट मेरी गलती थी, समस्या वास्तव में विंडोज़ पर मल्टीप्रोसेसिंग में है। मैंने लिनक्स पर इसी कोड की कोशिश की और यह अच्छी तरह से चलता है।

मुझे कोई त्रुटि संदेश नहीं मिलता है क्योंकि यह क्रैश नहीं होता है, यह बस कोई सार्थक काम करना बंद कर देता है।

@adverley क्या आप अपने Windows बॉक्स पर GitHub के नवीनतम संस्करण को

फीसबैक की कमी के कारण बंद हो रहा है और यह शायद एक ज्ञात मुद्दा है जो नए जॉबलिब में तय किया गया है।

सुनिश्चित नहीं है कि संबंधित है, ऐसा प्रतीत होता है।

विंडोज़ में, कस्टम स्कोरर अभी भी जम जाता है। मुझे Google पर इस धागे का सामना करना पड़ा - स्कोरर को हटा दिया, और ग्रिड खोज काम करता है।

जब यह जम जाता है, तो यह कोई त्रुटि संदेश नहीं दिखाता है। 3 अजगर प्रक्रियाएं भी पैदा हुई हैं (क्योंकि मैंने n_jobs=3 सेट किया है)। हालाँकि, सभी पायथन प्रक्रियाओं के लिए CPU उपयोग 0 रहता है। मैं आईपीथन नोटबुक का उपयोग कर रहा हूं।

क्या आप स्कोरर का कोड साझा कर सकते हैं? यह थोड़ा असंभव लगता है।

क्या आपका स्कोरर कहीं भी joblib / n_jobs का उपयोग करता है? यह नहीं होना चाहिए, और इससे समस्याएं हो सकती हैं (हालांकि मुझे लगता है कि जॉबलिब को इसका पता लगाना चाहिए)।

ज़रूर - यहाँ पूरा कोड है - http://pastebin.com/yUE26SNs

स्कोरर फ़ंक्शन "स्कोर_मॉडल" है, यह जॉबलिब का उपयोग नहीं करता है।

यह कमांड प्रॉम्प्ट से चलता है, लेकिन IPython नोटबुक से नहीं। त्रुटि संदेश है -
AttributeError: Can't get attribute 'score_model' on <module '__main__' (built-in)>;

तब IPython और सभी उत्पन्न अजगर उदाहरण निष्क्रिय हो जाते हैं - चुपचाप - और जब तक मैं इसे पुनः आरंभ नहीं करता तब तक किसी भी अजगर कोड का जवाब नहीं देता।

विशेषता त्रुटि को ठीक करें, फिर यह काम करेगा।
क्या आप IPython नोटबुक में pylab आयात करते हैं? नहीं तो सब कुछ वैसा ही होना चाहिए।

खैर, मुझे नहीं पता कि विशेषता त्रुटि का कारण क्या है ... हालांकि यह सबसे अधिक संभावना है कि जॉबलिब्स से संबंधित है, क्योंकि _it केवल तभी होता है जब n_jobs 1_ से अधिक हो, n_jobs=1 साथ ठीक चलता है।

विशेषता के बारे में त्रुटि वार्ता score_model से लापता __main__ , या नहीं, मैं एक if __name__ == '__main__' IPython नोटबुक में है या नहीं।

(मुझे एहसास हुआ कि त्रुटि रेखा गलत तरीके से ऊपर चिपकाई गई थी - मैंने उपरोक्त पोस्ट में संपादित किया है।)

मैं पाइलैब का उपयोग नहीं करता।

यहाँ पूर्ण विस्तारित त्रुटि संदेश है - http://pastebin.com/23y5uHT2

हम, यह संभवतः विंडोज़ पर मल्टीप्रोसेसिंग के मुद्दों से संबंधित है। शायद @GaelVaroquaux या @ogrisel मदद कर सकता है।
मुझे नहीं पता कि नोटबुक __name__ == "__main__" ।
मीट्रिक को नोटबुक में परिभाषित न करने का प्रयास करें, लेकिन एक अलग फ़ाइल में और इसे आयात करें। मुझे लगता है कि इसे ठीक कर देगा।
यह वास्तव में GridSearchCV से संबंधित नहीं है, लेकिन विंडोज़ मल्टीप्रोसेसिंग, IPython नोटबुक और जॉबलिब के बीच कुछ दिलचस्प बातचीत है।

दोस्तों... सूत्र के लिए धन्यवाद। वैसे भी मुझे पहले इस धागे की जाँच करनी चाहिए थी, इस पर अपना ५ घंटे का समय बर्बाद किया। समानांतर प्रसंस्करण में चलाने की कोशिश कर रहा है। बहुत - बहुत धन्यवाद :)
एक प्रतिक्रिया जोड़ने के लिए: यह अभी भी जम रहा है। मुझे उसी मुद्दे का सामना करना पड़ा जब मेरे अपने मेक_स्कोर लागत फ़ंक्शन की उपस्थिति में..मेरा सिस्टम जमने लगता है। जब मैंने कस्टम लागत फ़ंक्शन का उपयोग नहीं किया, तो मुझे समानांतर प्रसंस्करण में इन फ्रीज का सामना नहीं करना पड़ा

इन 5 घंटों को परियोजना के लिए उपयोगी किसी चीज़ में बदलने का सबसे अच्छा तरीका यह होगा कि हम समस्या को पुन: उत्पन्न करने वाला एक स्टैंड-अलोन उदाहरण प्रदान करें।

मैं एक नेस्टेड क्रॉस-सत्यापन और n_jobs = -1 के भीतर एक कस्टम स्कोरर का उपयोग करने की कोशिश कर रहे ज्यूपिटर नोटबुक में काम कर रहे विंडोज 10 पर एक ही समस्या का सामना कर रहा था। मुझे AttributeError: Can't get attribute 'custom_scorer' on <module '__main__' (built-in)>; संदेश मिल रहा था।
जैसा कि @amueller ने सुझाव दिया था, कस्टम स्कोरर को नोटबुक कार्यों में परिभाषित करने के बजाय आयात करना।

मुझे OSX 10.10.5 . पर ठीक वैसी ही समस्या है

मेरा भी यही विचार है।
ओएसएक्स 10.12.5

कृपया एक प्रतिलिपि प्रस्तुत करने योग्य कोड स्निपेट दें। हम इसकी तह तक जाना पसंद करेंगे। डेटा सहित कोड के बिना समझना मुश्किल है, जो हमें समस्या दिखाता है।

बस इन पंक्तियों को एक अजगर खोल में चलाएँ

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)

ध्यान दें कि पीसीए चरण को पाइपलाइन से हटाने से समस्या हल हो जाती है।

और जानकारी:

डार्विन-16.6.0-x86_64-i386-64bit
('पायथन', '2.7.13 (डिफ़ॉल्ट, 4 अप्रैल 2017, 08:47:57) \n[GCC 4.2.1 संगत Apple LLVM 8.1.0 (clang-802.0.38)]')
('NumPy', '1.12.1')
('SciPy', '0.19.1')
('स्किकिट-लर्न', '0.18.2')

यह देखते हुए कि आप एक कस्टम स्कोरर का उपयोग नहीं करते हैं, क्या हमें यह मान लेना चाहिए कि a
अलग मुद्दा?

8 अगस्त 2017 6:15 बजे, "boazsh" [email protected] लिखा है:

बस इन पंक्तियों को एक अजगर खोल में चलाएँ

sklearn.decomposition आयात PCAसे sklearn.svm sklearn से SVC आयात करें।

एक्स = एनपी.यादृच्छिक नमूना ((1000, 100))
वाई = एनपी। यादृच्छिक। नमूना ((1000))> 0.5
svc_pipeline = पाइपलाइन ([('पीसीए', पीसीए (n_components = 95)), ('svc', SVC ())])
भविष्यवाणियां = cross_val_predict(svc_pipeline, X, Y, cv=30, n_jobs=-1)प्रिंट वर्गीकरण_रिपोर्ट(Y, भविष्यवाणियां)

ध्यान दें कि पीसीए चरण को पाइपलाइन से हटाने से समस्या हल हो जाती है।

और जानकारी:

स्किकिट-लर्न ==0.18.2
scipy==0.19.1
सुन्न == 1.12.1

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की थी।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment-320885103 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/AAEz6-6Klhc67b5kZ17fFTxc8RfZQ_BWks5sWBkLgaJpZM4BkiD9
.

जब मुझे पहली बार इस मुद्दे का सामना करना पड़ा तो मैं कस्टम स्कोरर का उपयोग कर रहा था, लेकिन जितना संभव हो सके उदाहरण कोड को सरल बनाने की कोशिश करते हुए, मैंने पाया कि इसमें कस्टम स्कोरर होना जरूरी नहीं है। कम से कम मेरी मशीन पर। स्कोरर को आयात करने से भी मेरे मामले में मदद नहीं मिली। वैसे भी, लक्षण समान दिखते हैं। स्क्रिप्ट हमेशा के लिए हैंग हो जाती है और CPU उपयोग कम होता है।

@boazsh स्निपेट के लिए बहुत बहुत धन्यवाद, हालांकि यह नियतात्मक नहीं है, क्या आप इसे संपादित कर सकते हैं और यह सुनिश्चित करने के लिए np.random.RandomState कर सकते हैं कि प्रत्येक रन पर यादृच्छिक संख्या हमेशा समान होती है।

यदि आप उदाहरण के लिए https://github.com/scikit-learn/scikit-learn/issues/5115#issuecomment -187683383 में उदाहरण के लिए सुझाए गए पायथन 3 का उपयोग कर रहे हैं, तो एक कार्य-आसपास भी है।

मेरे पास इस समय OSX पर इसका परीक्षण करने का कोई तरीका नहीं है, लेकिन मैं आने वाले दिनों में कोशिश करने में सक्षम हो सकता हूं।

उपयोगी जानकारी के कुछ अंश (बस अपनी पिछली टिप्पणी में जो कमी है उसे जोड़ें 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__)

इसके अलावा, आपने ओएसएक्स पैकेज मैनेजर (काढ़ा, आदि ...) में से एक के साथ, पाइप के साथ, कोंडा के साथ स्किकिट-लर्न कैसे स्थापित किया?

स्निपेट अपडेट किया गया (np.random.seed का इस्तेमाल किया गया)

डार्विन-16.6.0-x86_64-i386-64bit
('पायथन', '2.7.13 (डिफ़ॉल्ट, 4 अप्रैल 2017, 08:47:57) \n[GCC 4.2.1 संगत Apple LLVM 8.1.0 (clang-802.0.38)]')
('NumPy', '1.12.1')
('SciPy', '0.19.1')
('स्किकिट-लर्न', '0.18.2')

स्निपेट अपडेट किया गया (np.random.seed का इस्तेमाल किया गया)

बढिया बहुत धन्यवाद!

इसके अलावा, आपने ओएसएक्स पैकेज मैनेजर (काढ़ा, आदि ...) में से एक के साथ, पाइप के साथ, कोंडा के साथ स्किकिट-लर्न कैसे स्थापित किया?

क्या आपने इसका उत्तर दिया है, मुझे आपका उत्तर नहीं मिल रहा है...

क्षमा करें, चूक गया - पिप।

एफडब्ल्यूआईडब्ल्यू, मुझे उस स्निपेट को चलाने में कोई समस्या नहीं है:

आयात मंच; प्रिंट (प्लेटफ़ॉर्म.प्लेटफ़ॉर्म ())
डार्विन-16.7.0-x86_64-i386-64bit
आयात प्रणाली; प्रिंट ("पायथन", sys.version)
पायथन 2.7.12 |Continuum Analytics, Inc.| (डिफ़ॉल्ट, 2 जुलाई 2016, 17:43:17)
[जीसीसी ४.२.१ (एप्पल इंक. बिल्ड ५६५८ पर आधारित) (एलएलवीएम बिल्ड २३३६.११.००)]
आयात सुन्न; प्रिंट ("NumPy", numpy.__version__)
न्यूमपी 1.13.1
आयात scipy; प्रिंट ("SciPy", scipy.__version__)
विज्ञानपी 0.19.1
आयात स्केलेर; प्रिंट ("स्किकिट-लर्न", स्केलेर्न.__संस्करण__)
स्किकिट-लर्न 0.18.2

क्या आप वर्बोज़=10 को cross_val_predict में भी डाल सकते हैं, ताकि हम शायद
देखें कि यह आपके लिए कहां टूटता है?

8 22:59 अगस्त 2017, boazsh [email protected] लिखा है:

क्षमा करें, चूक गया - पिप।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की थी।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment-320948362 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/AAEz67S64KIXUGvARGjvxBOw_4aCAdqhks5sWFu0gaJpZM4BkiD9
.

@jnothman मैं अनुमान लगा रहा हूं कि आपका कोंडा पर्यावरण एमकेएल का उपयोग करता है न कि तेज। यह ठंड की समस्या एक्सेलेरेट और पायथन मल्टीप्रोसेसिंग के लिए विशिष्ट है। http://scikit-learn.org/stable/faq.html#why -do-i-sometime-get-a-crash-freeze-with-n-jobs-1-under-osx-or-linux अधिक जानकारी के लिए .

दूसरी ओर pip उन पहियों का उपयोग करेगा जो Accelerate (लेखन के समय) के साथ भेजे जाते हैं।

इस विशेष बग से बचने के लिए वर्कअराउंड (JOBLIB_START_METHOD के अलावा) एमकेएल (जैसे कोंडा के माध्यम से) या ओपनबीएलएएस (उदाहरण के लिए कोंडा-फोर्ज चैनल के माध्यम से) का उपयोग करना है।

कुछ भी नहीं छापा जा रहा है...

@jnothman मैं अनुमान लगा रहा हूं कि आपका कोंडा पर्यावरण एमकेएल का उपयोग करता है न कि तेज।

@jnothman यदि आप समस्या को पुन: उत्पन्न करना चाहते हैं, तो

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

एफडब्ल्यूआईडब्ल्यू मैं अपने ओएस एक्स वीएम पर समस्या को पुन: पेश नहीं कर सकता। मैंने जितना संभव हो सके @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')

हम्म वास्तव में मैं पुन: पेश कर सकता हूं लेकिन आपका स्निपेट पूर्ण पुनरुत्पादक नहीं था। यहाँ एक अद्यतन स्निपेट है:

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

किसी भी मामले में, यह Accelerate और Python मल्टीप्रोसेसिंग के साथ एक ज्ञात समस्या है। वर्कअराउंड मौजूद हैं और पहले की पोस्ट में सूचीबद्ध किए गए हैं। सबसे आसान तरीका शायद कोंडा का उपयोग करना है और यह सुनिश्चित करना है कि आप एमकेएल का उपयोग करें न कि एक्सीलरेट करें।

लंबी अवधि में (शायद scikit-learn 0.20) इस समस्या को जॉबलिब के लिए नए लोकी बैकएंड द्वारा सार्वभौमिक रूप से हल किया जाएगा: https://github.com/scikit-learn/scikit-learn/issues/7650

मल्टीप्रोसेसिंग के लिए स्किकिट-लर्न वर्जन पर निर्भर होना वेंडरिंग की समस्याओं का लक्षण है ....

मल्टीप्रोसेसिंग के लिए स्किकिट-लर्न वर्जन पर निर्भर होना वेंडरिंग की समस्याओं का लक्षण है ....

मैंने हाल ही में निम्नलिखित पढ़ा, जो मुझे दिलचस्प लगा:
https://lwn.net/Articles/730630/rss

मेरे पास RandomizedSearchCV के साथ एक समान समस्या है; यह अनिश्चित काल तक लटका रहता है। मैं 3 साल पुराने मैकबुक प्रो, 16GB रैम और कोर i7 का उपयोग कर रहा हूं और मेरा स्किकिट-लर्न वर्जन 0.19 है।

हैरान करने वाली बात यह है कि यह पिछले शुक्रवार को काम कर रहा था !!! सोमवार की सुबह, मैं वापस जाता हूं और दौड़ने की कोशिश करता हूं और यह जम जाता है। मैं पिछले रनों से जानता हूं कि इसे खत्म होने में लगभग ६० मिनट लगते हैं, लेकिन मैंने इससे बहुत लंबा इंतजार किया और कुछ नहीं हुआ, यह बस हैंग हो गया, कोई त्रुटि संदेश नहीं, कुछ भी नहीं और मेरा कंप्यूटर गर्म हो जाता है और बिजली चूसता है जैसे कल नहीं है। नीचे कोड। मैंने यहां कुछ टिप्पणियों को पढ़ने के बाद n_iter को 2 और n_jobs=1 में बदलने की कोशिश की और यह काम कर गया। तो इसका n_jobs=-1 से कुछ लेना-देना हो सकता है। फिर भी, इस कोड ने पिछले शुक्रवार को ठीक काम किया! यह सिर्फ सोमवार से नफरत करता है। मेरे डेटासेट का आकार कम है कि 20k उदाहरण आयामीता के साथ <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

सीआरएफ क्या है? संभावना को खत्म करने के लिए, क्या आप इसका उपयोग करने का प्रयास कर सकते हैं
वापसी_ट्रेन_स्कोर=गलत?

यह बहुत संभव है कि यह @KaisJM की समस्या मल्टीप्रोसेसिंग के साथ त्वरण पर प्रसिद्ध सीमा के कारण है, हमारे अक्सर पूछे जाने वाले प्रश्न देखें।

आपने स्किकिट-लर्न कैसे स्थापित किया?

भविष्य के संदर्भ के लिए, क्या आप इसका आउटपुट पेस्ट कर सकते हैं:

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

यह पिछले शुक्रवार काम कर रहा था !! मैंने तब से कुछ नहीं किया। मुझे लगता है कि विज्ञान सीखना एनाकोंडा का हिस्सा है, लेकिन मैंने पाइप (पाइप इंस्टॉल - अपग्रेड स्केलेर) के साथ अपग्रेड किया था, लेकिन इससे पहले कि मुझे यह समस्या मिली .. मैंने 0.19 में अपग्रेड करने के बाद कोड ठीक चलाया।

यहाँ उपरोक्त प्रिंटों का आउटपुट है:

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 : मैं sklearn.grid_search से RandomizedSearchCV का उपयोग कर रहा हूं जिसमें return_train_score पैरामीटर नहीं है। मुझे पता है कि sklearn.grid_search को हटा दिया गया है .. मैं sklearn.model_selection से कोशिश करूंगा, लेकिन कुछ मुझे बताता है कि मेरे पास एक ही सटीक मुद्दा होगा)। अधिक जानकारी और कोड के साथ अद्यतन मूल टिप्पणी।

क्या आप conda list | grep numpy का आउटपुट पोस्ट कर सकते हैं। मुझे लगता है कि पाइप के साथ विज्ञान-सीखने को अपडेट करके आपने पाइप के साथ भी numpy अपडेट किया है और आपको नुकीले पहिये मिल गए हैं जो त्वरण का उपयोग करते हैं और ऊपर उल्लिखित सीमा है।

सलाह का छोटा शब्द:

• पूरी तरह से स्टैंड-अलोन स्निपेट पोस्ट करें (आपके अगले अंक के लिए)। इसका मतलब है कि कोई भी इसे IPython सत्र में कॉपी और पेस्ट कर सकता है और आसानी से पुन: पेश करने का प्रयास कर सकता है। इससे आपको अच्छा फीडबैक मिलने का सबसे अच्छा मौका मिलेगा।
• यदि आप कोंडा का उपयोग कर रहे हैं, तो कोंडा के माध्यम से उपलब्ध पैकेजों को प्रबंधित करने के लिए कोंडा से चिपके रहें। जब आपको करना हो तभी पाइप का उपयोग करें।
• यदि आप जोर देते हैं कि आप pip install --update का उपयोग करना चाहते हैं, तो मैं दृढ़ता से अनुशंसा करता हूं कि आप pip install --update --no-deps । अन्यथा यदि कोई पैकेज निर्भर करता है, तो numpy पर कहें, और आपके पास नवीनतम numpy नहीं है, numpy को pip के साथ अपग्रेड किया जाएगा, जो आप नहीं चाहते हैं।

अरे हाँ और BTW, sklearn.grid_search बहिष्कृत है आप शायद sklearn.model_selection का उपयोग एक बिंदु पर करना चाहते हैं जो सड़क से बहुत नीचे नहीं है।

अच्छी सलाह, धन्यवाद। तो क्या numpy को डाउनग्रेड करने का समाधान है? आप किस सीमा का जिक्र कर रहे हैं? ऊपर पूछे जाने वाले प्रश्न लिंक? मैंने इसे पढ़ा, लेकिन मुझे यह सामान समझ में नहीं आया (मैं सिर्फ एक अहंकारी आदमी हूँ :))।

conda list | grep numpy का आउटपुट

सुन्न 1.12.0
सुन्न 1.12.0 py27_0
सुन्न 1.13.1
numpydoc 0.7.0

वाह तीन numpy स्थापित मैंने पहले दो देखा लेकिन तीन कभी नहीं ... वैसे भी यह उस समस्या का संकेत देता है जिसका मैं उल्लेख कर रहा था, यानी कि आपके पास मिश्रित पाइप और कोंडा है जो किसी दिए गए पैकेज के लिए एक बुरा विचार है।

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

उम्मीद है कि उसके बाद आपके पास एक एकल अंक होगा जो एमकेएल का उपयोग करता है।

अगर मैं आप होते तो मैं दोबारा जांच करता कि आपको अन्य मुख्य वैज्ञानिक पैकेजों के लिए समान समस्या नहीं है, जैसे कि scipy, आदि ...

कुछ पैकेजों के लिए मैं पाइप का सहारा लेता हूं क्योंकि कोंडा में कुछ पैकेज नहीं होते हैं, जो वास्तव में बहुत निराशाजनक है क्योंकि मुझे पता है कि कोंडा के साथ पाइप मिलाना एक बुरा विचार है। अगली बार ऐसा होने पर मैं --no-deps विकल्प का उपयोग करूँगा।

एक बात जो मुझे बतानी चाहिए थी, वह यह है कि मैंने जिस अजगर में काम कर रहा था, उसके भीतर मैंने स्पाइडर स्थापित किया था। हालाँकि, मैं स्पाइडर और जुपिटर दोनों में, स्पाइडर स्थापित करने के बाद कोड चलाने में सक्षम था।

मैंने स्पाइडर और ऊपर के numpys को अनइंस्टॉल किया, कोंडा के साथ ऊबड़-खाबड़ फिर से स्थापित किया (जो कि स्किकिट को 0.19 में अपडेट किया गया) और फिर भी वही त्रुटि मिलती है। स्पाइडर इंस्टाल होने के कारण कुछ हुआ होगा, लेकिन फिर एक दिन काम क्यों करेगा और फिर अचानक बंद हो जाएगा ??

ठीक है, कुछ भी काम नहीं कर रहा !! क्या मुझे बस एक नया वातावरण बनाना चाहिए (कोंडा का उपयोग करके) और वहां सब कुछ फिर से स्थापित करना चाहिए? क्या यह इसे हल करेगा या इसे और खराब कर देगा?

एक कोशिश के काबिल लगता है!

एक नया env बनाया और कोंडा के साथ सब कुछ स्थापित किया, फिर भी अनिश्चित काल के लिए जमा देता है। प्रत्येक पैकेज आदि की केवल एक प्रति।

n_jobs=1 काम करता है, लेकिन निश्चित रूप से हमेशा के लिए लेता है (यह पिछले env में भी काम करता है)। n_jobs=-1 वह है जो अनिश्चित काल के लिए जम जाता है।

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

तब मुझे नहीं पता। जिस तरह से हम जांच कर सकते हैं, वह यह है कि आप एक पूरी तरह से स्टैंडअलोन स्निपेट पोस्ट करते हैं जिसे हम आईपीथन सत्र में कॉपी और पेस्ट कर सकते हैं और देख सकते हैं कि हम समस्या को पुन: उत्पन्न कर सकते हैं या नहीं।

एक न्यूनतम उदाहरण बनाने की कोशिश करेंगे जो समस्या को पुन: उत्पन्न करता है। मुझे और अधिक कुशलता से डीबग करने के लिए ऐसा करने की ज़रूरत है।

मैंने आपके द्वारा "त्वरित" के बारे में अक्सर पूछे जाने वाले प्रश्न प्रविष्टि को पढ़ा है .. यह मेरे लिए बहुत मददगार नहीं है। मैंने इससे जो लिया वह यह है कि कांटा() निष्पादन के बाद नहीं() कॉल खराब है। मैंने इस पर कुछ गुगल किया है और अब तक कुछ भी कामकाज पर संकेत नहीं देता है। क्या आप कुछ और जानकारी बता सकते हैं, समस्या क्या है इसके बारे में अधिक जानकारी? धन्यवाद,

इस स्निपेट को आज़माएं (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))

• यदि यह फ़्रीज हो जाता है (अर्थात यह एक सेकंड के भीतर समाप्त नहीं होता है) तो इसका अर्थ है कि आप Accelerate का उपयोग कर रहे हैं और फ़्रीज़ Python मल्टीप्रोसेसिंग के साथ एक ज्ञात सीमा है। कार्य-आसपास Accelerate का उपयोग नहीं करना है। ओएसएक्स पर आप कोंडा के साथ ऐसा कर सकते हैं जो डिफ़ॉल्ट रूप से एमकेएल का उपयोग करता है। आप Conda-forge का उपयोग करके OpenBLAS का भी उपयोग कर सकते हैं।
• यदि यह स्थिर नहीं होता है तो आप Accelerate का उपयोग नहीं कर रहे हैं, और हमें जांच करने के लिए एक स्टैंड-अलोन स्निपेट की आवश्यकता होगी।

न्यूनतम कोड के साथ पुन: पेश करने का प्रयास करेंगे।

Without multiprocessing:
Enter
Exit

With multiprocessing:
Enter
Exit
Enter
Exit

@GaelVaroquaux scikit-learn एक ऐप नहीं बल्कि एक समृद्ध पारिस्थितिकी तंत्र में एक पुस्तकालय है। अगर हर कोई वही करता जो हम करते हैं, तो सब कुछ दुर्घटनाग्रस्त हो जाएगा। यह एक स्पष्ट संकेत है कि हमें बदलने की जरूरत है। और ऐसे कई वातावरण हैं जहां उस टिप्पणी से विपरीत सत्य है।

मैंने Google क्लाउड कंप्यूट इंजन में एक ubuntu वर्चुअल इंस्टेंस का उपयोग किया (उबड़-खाबड़, मसालेदार, स्किकिट आदि सबसे अद्यतित नहीं थे)। कोड ठीक चला। फिर मैंने जेनसिम स्थापित किया। इसने नवीनतम संस्करणों के लिए numpy और scipy को अपडेट किया और कुछ अन्य चीजों को स्थापित किया जिनकी इसे आवश्यकता है (boto, bz2file और smart_open)। उसके बाद कोड फ्रीज हो जाता है। मुझे आशा है कि यह एक उपयोगी सुराग देता है कि इस फ्रीज का कारण क्या है।

Gensim . स्थापित करने के बाद
numpy (1.10.4) को numpy (1.13.3) में अपडेट किया गया
scipy (0.16.1) को scipy में अपडेट किया गया (0.19.1)

और जानकारी:
कुछ शोध करने पर मैंने पाया कि मेरे /usr/lib/ से libblas, liblapack और liblapack_atlas गायब थे, साथ ही मैंने /usr/lib/atlas-base/ निर्देशिका नहीं देखी। मुझे नहीं पता कि वे वहां थे और जेन्सिम स्थापित करने से उन्हें हटा दिया गया क्योंकि यह numpy आदि अपडेट किया गया था, लेकिन यह संभव है क्योंकि कोड जेन्सिम स्थापित करने से पहले काम करता था। मैंने उन्हें उन्नत स्किकिट इंस्टॉलेशन निर्देशों के अनुसार sudo apt-get --yes install libatlas-base-dev और "_update-alternatives_" का उपयोग करके स्थापित किया, लेकिन इससे कोई फायदा नहीं हुआ, कोड अभी भी n_jobs=-1 के साथ जम जाता है।

मुझे लगता है कि समस्या यह है कि numpy OpenBlas का उपयोग कर रहा है। इसे एटलस में बदल देंगे और देखेंगे कि क्या होता है।

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

अभी भी वही समस्या। निम्नलिखित ठीक चलता है, जब तक कि मैं 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 ATLAS या OpenBLAS का उपयोग करके आपके Numpy और Scipy इंस्टॉलेशन हैं?

आपने जो @KaisJM किया है, उसका पालन करना थोड़ा कठिन है। एक अनुरक्षक के दृष्टिकोण से हमें जो चाहिए वह पूरी तरह से स्टैंड-अलोन पायथन स्निपेट है यह देखने के लिए कि क्या हम पुन: पेश कर सकते हैं। अगर हम पुनरुत्पादन कर सकते हैं, तभी हम जांच कर सकते हैं और समझने की कोशिश कर सकते हैं कि क्या हो रहा है। यदि ऐसा केवल तब होता है जब आप जेन्सिम स्थापित करते हैं और आप इस व्यवहार को लगातार पुन: उत्पन्न करने का प्रबंधन करते हैं, तो हमें पूर्ण निर्देशों की आवश्यकता होगी कि एक पायथन वातावरण कैसे बनाया जाए जिसमें समस्या बनाम पायथन वातावरण है जिसमें समस्या नहीं है।

इसके लिए समय और प्रयास की एक नगण्य राशि की आवश्यकता है, मैं पूरी तरह से सहमत हूं, लेकिन इसके बिना, मुझे डर है कि आप जिस समस्या का सामना कर रहे हैं उसकी जांच करने के लिए हम बहुत कुछ नहीं कर सकते हैं।

उन्नत स्थापना निर्देशों के अनुसार

@KaisJM वैसे, यह पृष्ठ पुराना है, क्योंकि आजकल पहिए लिनक्स पर उपलब्ध हैं और उनमें स्वयं का OpenBLAS है। यदि आप पाइप के साथ एक जारी स्किकिट-लर्न स्थापित करते हैं तो आप OpenBLAS का उपयोग कर रहे होंगे।

@lesteve क्या आप कह रहे हैं कि ओपनब्लास अब फ्रीज नहीं करता है?

@lesteve paula ने एक स्निपेट पोस्ट किया है जिसमें भी यही समस्या है। मैं देख सकता हूं कि यह पूरा कोड नहीं है, लेकिन मुझे आशा है कि यह कुछ सुराग देगा। मैं यहां स्निपेट "पूर्ण" बना सकता हूं और आपके लिए पोस्ट कर सकता हूं। हालांकि, यह स्पष्ट है कि "पुराना" - जैसा कि आप इसे कहते हैं - निर्देश पृष्ठ इतना पुराना नहीं हो सकता है। सबसे अधिक संभावना यह है कि OpenBLAS उस पृष्ठ में जिस फीस के बारे में बात कर रहा है, उसका कारण बन रहा है।

ये निर्देश पुराने हैं मेरा विश्वास करो। यदि आप विवरण में पढ़ते हैं, तो यह कहता है "लेकिन OpenBLAS संस्करण 0.2.8-4 से पहले जॉबलिब/मल्टीप्रोसेसिंग को फ्रीज कर सकता है"। मैंने हाल ही में एक सुन्न पहिया की जाँच की और इसमें OpenBLAS ०.२.८.१८ है। वे जिस फ्रीज का जिक्र कर रहे हैं, वह https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment -334155175 में से एक है, जो आपके पास नहीं है।

मैं देख सकता हूं कि यह पूरा कोड नहीं है, लेकिन मुझे आशा है कि यह कुछ सुराग देगा

नहीं वास्तव में कोई नहीं। हमारे पास ऐसे उपयोगकर्ताओं की रिपोर्ट है जो यह इंगित करते हैं कि ठंड अभी भी हो सकती है, जिनमें से कोई भी हम AFAIK को पुन: पेश करने में कामयाब नहीं हुए हैं। ऐसा लगता है कि यह समस्या कारकों के कुछ विशिष्ट संयोजनों में होती है। जब तक समस्या वाले किसी व्यक्ति को कुछ समय नहीं लगता है और यह पता नहीं चलता है कि नियंत्रित तरीके से कैसे पुनरुत्पादन करना है और हम पुन: उत्पन्न करने का प्रबंधन नहीं करते हैं, तो हम इसके बारे में कुछ भी नहीं कर सकते हैं।

मैं यहां स्निपेट "पूर्ण" बना सकता हूं और आपके लिए पोस्ट कर सकता हूं

वह महान होगा। यह बहुत अच्छा होगा यदि आप जांच सकते हैं कि क्या ऐसा स्निपेट अभी भी एक अलग कोंडा वातावरण (या वर्चुअलएन्व जो आप उपयोग करते हैं उसके आधार पर फ्रीज का कारण बनता है)।

@lesteve @paulaceccon : मैंने पाउला का अंश कोड लिया और एक पूर्ण रन-सक्षम कोड स्निपेट बनाया। बस इसे ज्यूपिटर सेल में पेस्ट करें और चलाएं। पाउला: मैं इस स्निपेट को फ्रीज नहीं कर सका। ध्यान दें कि n_jobs=-1 और ठीक चलता है। बहुत अच्छा होगा यदि आप एक नज़र डाल सकते हैं और इसका एक संस्करण पोस्ट कर सकते हैं जो फ़्रीज़ हो जाता है। ध्यान दें कि आप grid_search मॉड्यूल और model_selection मॉड्यूल के बीच स्विच कर सकते हैं, दोनों मेरे लिए ठीक रहे।

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 मुझे लगता है कि यह अधिक उपयोगी है यदि आप अपनी फ्रीजिंग स्क्रिप्ट से शुरू करते हैं और पूरी तरह से स्टैंड-अलोन को सरल और पोस्ट करने का प्रबंधन करते हैं जो आपके लिए फ्रीज करता है।

@lesteve सहमत हुए। मैंने एक नया पायथन 2 वातावरण बनाया जैसा कि मैंने जेन्सिम को स्थापित करने से पहले किया था। कोड ठीक चला, n_jobs = -1 के साथ कोई फ्रीज नहीं। क्या अधिक है, Numpy OpenBLAS का उपयोग कर रहा है और वातावरण के समान कॉन्फ़िगरेशन है जो फ़्रीज़ प्रदर्शित करता है (वह स्थान जहाँ Gensim स्थापित किया गया था)। तो ऐसा लगता है कि ओपनब्लास इस फ्रीज का कारण नहीं है।

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 मैं यहाँ (विंडोज़) एक ही स्निपेट चला रहा हूँ और यह जम जाता है।

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

मुझे पता है कि यह अजीब है लेकिन _custom_ मीट्रिक के साथ चलने पर यह जमता नहीं है।

मुझे एक ऐसी ही समस्या है। मैं एक ही कोड चला रहा हूं और बस नए महीने के डेटा के साथ मॉडल को अपडेट करना चाहता था और यह चलना बंद हो गया। मेरा मानना ​​है कि इस बीच स्केलेर को 0.19 . पर अपडेट किया गया

एक लूप में GridSearchCV या RandomizedSearchCV चलाना और n_jobs> 1 बृहस्पति और 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)

    ...

@lesteve अनुशंसा का पालन किया और पर्यावरण की जांच की और पाइप के साथ स्थापित numpy हटा दिया:

डार्विन-16.6.0-x86_64-i386-64bit
पायथन 3.6.1 |एनाकोंडा कस्टम (x86_64)| (डिफ़ॉल्ट, 11 मई 2017, 13:04:09)
[जीसीसी ४.२.१ संगत एप्पल एलएलवीएम ६.० (क्लैंग-६००.०.५७)]
न्यूमपी 1.13.1
विज्ञानपी 0.19.1
स्किकिट-लर्न 0.19.0

$conda सूची | ग्रेप सुन्न
गनम्पी ०.२ पिप
सुन्न 1.13.1 py36_0
सुन्न १.१३.३ पाइप
numpydoc 0.6.0 py36_0

$पाइप अनइंस्टॉल numpy

$conda सूची | ग्रेप सुन्न
गनम्पी ०.२ पिप
सुन्न 1.13.1 py36_0
numpydoc 0.6.0 py36_0

$conda numpy -f स्थापित करें // सबसे अधिक संभावना अनावश्यक

$conda सूची | ग्रेप सुन्न
गनम्पी ०.२ पिप
सुन्न 1.13.1 py36_0
numpydoc 0.6.0 py36_0

मेरी समस्या को ठीक किया।

@paulaceccon आपकी समस्या से संबंधित है

https://stackoverflow.com/questions/36533134/cant-get-attribute-abc-on-module-main-from-abc-h-py
यदि आप उस फ़ंक्शन को घोषित करने से पहले पूल घोषित करते हैं जिसे आप समानांतर में उपयोग करने का प्रयास कर रहे हैं तो यह इस त्रुटि को फेंक देगा। आदेश को उलट दें और यह अब इस त्रुटि को नहीं फेंकेगा।

निम्नलिखित आपका कोड चलाएगा:

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

बाहरी.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)

8 कोर पर चल रहे परिणाम

५४ उम्मीदवारों में से प्रत्येक के लिए ३ गुना फिटिंग, कुल १६२ फिट
{'वर्ग_वजन': {0: 0.51891309, 1: 13.71835531}, 'मानदंड': 'गिनी', 'min_samples_leaf': 10, 'min_samples_split': 20, 'n_estimators': 400}

समस्या अभी भी है दोस्तों। मैं एक कस्टम स्कोरर का उपयोग कर रहा हूं और जब मैं n_jobs को किसी भी चीज़ पर सेट करता हूं तो यह हमेशा के लिए चलता रहता है। जब मैं n_jobs बिल्कुल निर्दिष्ट नहीं करता तो यह ठीक काम करता है लेकिन अन्यथा यह जम जाता है।

क्या आप समस्या को पुन: उत्पन्न करने के लिए एक स्टैंड-अलोन स्निपेट प्रदान कर सकते हैं? अधिक जानकारी के लिए कृपया https://stackoverflow.com/help/mcve पढ़ें।

अभी भी एक ही नमूना कोड के साथ इस समस्या का सामना करना पड़ रहा है।

विंडोज़-10.0.15063-SP0
पायथन 3.6.4 |एनाकोंडा कस्टम (64-बिट)| (डिफ़ॉल्ट, जनवरी १६ 2018, १०:२२:३२) [एमएससी v.१९०० ६४ बिट (एएमडी६४)]
न्यूमपी 1.14.1
विज्ञानपी 1.0.0
स्किकिट-लर्न 0.19.1

क्या आप समस्या को पुन: उत्पन्न करने के लिए एक स्टैंड-अलोन स्निपेट प्रदान कर सकते हैं? अधिक जानकारी के लिए कृपया https://stackoverflow.com/help/mcve पढ़ें।

मुझे संदेह है कि विंडोज़ मुद्दे में यह वही पुरानी मल्टीप्रोसेसिंग है। हमारे अक्सर पूछे जाने वाले प्रश्न देखें

मैंने थॉम्बर्ग1 के https://github.com/scikit-learn/scikit-learn/issues/2889#issuecomment -337985212 में कोड का परीक्षण किया।

ओएस: विंडोज 10 x64 10.0.16299.309
पायथन पैकेज: WinPython-64bit-3.6.1
सुन्न (1.14.2)
स्किकिट-लर्न (0.19.1)
scipy (1.0.0)

इसने जुपिटर नोटबुक और कमांड-लाइन में ठीक काम किया।

हाय, मुझे एक ही समस्या है, इसलिए मैं नया खोलना नहीं चाहता था जिससे लगभग समान धागा हो सके।

-मैक ओएस
-एनाकोंडा
-स्किकिट-लर्न 0.19.1
-स्किपी 1.0.1
-सुन्न 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))

कोड एक ट्यूटोरियल से है: https://machinelearningmastery.com/use-keras-deep-learning-models-scikit-learn-python/
मैंने n_jobs पैरामीटर को 1, -1 में बदलने की कोशिश की, लेकिन इनमें से कोई भी काम नहीं किया। कोई संकेत?

यह चलता है अगर मैं मल्टीप्रोसेसिंग आयात जोड़ता हूं और अगर कथन नीचे दिखाया गया है - मैं केरस के साथ काम नहीं करता हूं इसलिए मेरे पास अधिक अंतर्दृष्टि नहीं है

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

18 उम्मीदवारों में से प्रत्येक के लिए 3 गुना फिटिंग, कुल 54 फिट

सर्वोत्तम: ०.६७५७८१ {'batch_size': 5, 'epochs': 5, 'init': 'glorot_uniform', 'optimizer': 'adam'} का उपयोग कर
०.६२१०९४ (०.०३६२२५) इसके साथ: {'बैच_साइज': 5, 'एपोच': 5, 'इनिट': 'ग्लोरोट_यूनिफॉर्म', 'ऑप्टिमाइज़र': 'आरएमएसप्रॉप'}
०.६७५७८१ (०.००६३७९) के साथ: {'बैच_साइज़': 5, 'युग': 5, 'इनिट': 'ग्लोरोट_यूनिफ़ॉर्म', 'ऑप्टिमाइज़र': 'एडम'}
...
०.६५१०४२ (०.०२५७८०) के साथ: {'बैच_साइज़': 20, 'युग': 5, 'इनिट': 'यूनिफ़ॉर्म', 'ऑप्टिमाइज़र': 'एडम'}

यदि आवश्यक हो तो संस्करण जानकारी
sys 3.6.4 |एनाकोंडा कस्टम (64-बिट)| (डिफ़ॉल्ट, जनवरी १६ 2018, १२:०४:३३)
[जीसीसी 4.2.1 संगत बजना 4.0.1 (टैग/RELEASE_401/अंतिम)]
सुन्न 1.14.2
पांडा 0.22.0
स्केलेर 0.19.1
मशाल 0.4.0a0+9692519
आईपीथन 6.2.1
केरस 2.1.5

कंपाइलर: जीसीसी 4.2.1 संगत क्लैंग 4.0.1 (टैग/RELEASE_401/फाइनल)
प्रणाली: डार्विन
रिलीज: 17.5.0
मशीन: x86_64
प्रोसेसर: i386
सीपीयू कोर: 24
दुभाषिया: 64 बिट

धन्यवाद @ थॉम्बर्ग१ , लेकिन जोड़

import multiprocessing
if __name__ == '__main__':

कोई सहायता नहीं की। समस्या अभी भी वही है

GridsearchCV में अनुकूलित स्कोरिंग फ़ंक्शन का उपयोग करते समय मेरी मशीन पर भी यही समस्या है।
अजगर 3.6.4,
स्किकिट-लर्न 0.19.1,
विंडोज 10।,
सीपीयू कोर: 24

@byrony क्या आप पुन: पेश करने के लिए कोड प्रदान कर सकते हैं? क्या आपने if __name__ == "__main__" ?

मैंने अपनी मशीन पर n_jobs=-1 या n_jobs=8 को GridsearchCV तर्क के रूप में उपयोग करते समय डिफ़ॉल्ट स्कोरर तर्क का उपयोग करते समय कई बार इसी तरह की समस्या का अनुभव किया है।

• पायथन 3.6.5,
• स्किकिट-लर्न 0.19.1,
• आर्क लिनक्स,
• सीपीयू कोर: 8.

यहां वह कोड है जिसका मैंने उपयोग किया था:

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

मुझे पता है कि एक बड़ा डेटासेट है इसलिए मुझे उम्मीद थी कि परिणाम प्राप्त करने में कुछ समय लगेगा लेकिन फिर 2 दिनों के चलने के बाद, इसने काम करना बंद कर दिया (स्क्रिप्ट निष्पादित होती रहती है लेकिन रैम और स्वैप के अलावा किसी भी संसाधन का उपयोग नहीं कर रही है)।

अग्रिम में धन्यवाद!

@amueller मैंने if __name__ == "__main__" उपयोग नहीं किया। नीचे मेरा कोड है, यह केवल तभी काम करता है जब 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)

आप XGBoost का उपयोग कर रहे हैं। मुझे नहीं पता कि वे आंतरिक रूप से क्या करते हैं, यह बहुत संभव है कि यह मुद्दा है। क्या आप यह देखने की कोशिश कर सकते हैं कि if __name__ जोड़ने से मदद मिलती है या नहीं?
अन्यथा मुझे नहीं लगता कि इसके लिए अभी कोई समाधान है।

@ Pazitos10 क्या आप सिंथेटिक डेटा और/या छोटे डेटा के साथ पुन: पेश कर सकते हैं? मैं आपके डेटा के बिना पुन: पेश नहीं कर सकता और कम समय में पुन: पेश करना अच्छा होगा।

@amueller ठीक है, मैं इसे फिर से 500k पंक्तियों के साथ

@amueller , 50k पंक्तियों के साथ स्क्रिप्ट चलाना अपेक्षा के अनुरूप काम करता है। स्क्रिप्ट सही ढंग से समाप्त होती है, परिणाम इस प्रकार दिखा रही है (क्षमा करें, मेरा मतलब 50k 500k नहीं था):

समस्या यह है कि मुझे नहीं पता कि ये परिणाम मेरे पूरे डेटासेट के लिए सर्वश्रेष्ठ होंगे या नहीं। कोई सलाह?

ऐसा लगता है कि आप राम से बाहर भाग रहे हैं। शायद इसके बजाय केरस का उपयोग करने का प्रयास करें, यह संभवतः बड़े पैमाने पर तंत्रिका जाल के लिए एक बेहतर समाधान है।

@amueller ओह, ठीक है। मैं इसके बजाय केरस का उपयोग करने की कोशिश करूंगा। फिर से धन्यवाद!

इसका कस्टम स्कोरर से कोई लेना-देना नहीं है। यह विंडोज़ पर पायथन मल्टीप्रोसेसिंग की एक प्रसिद्ध विशेषता है: आपको n_jobs=-1 का उपयोग करने वाली हर चीज को if __name__ == '__main__' ब्लॉक में चलाना होगा या आपको फ्रीज/क्रैश मिलेगा। हो सकता है कि हमें इसे कहीं प्रमुख रूप से दस्तावेज करना चाहिए, उदाहरण के लिए रीडमे में?

क्या यह शायद विज्ञान के लिए एक विचार है, कि विंडोज़ के मामले में फ़ंक्शन को बदलने के लिए?
और कार्यकर्ता प्रक्रियाओं के संग्रह में कार्यों को फीड करने और परिणाम एकत्र करने के लिए कतारों का उपयोग करें
जैसा कि यहां बताया गया है: https://docs.python.org/2/library/multiprocessing.html#windows
और यहां 3.6 के लिए: https://docs.python.org/3.6/library/multiprocessing.html#windows

@PGTBoos यह स्किकिट-लर्न 0.20.0 . में तय है