Scikit-learn: SGDClassifier को भविष्यवाणी करने के साथ-साथ लॉजिस्टिक रिग्रेशन प्राप्त करना

Question

लॉजिस्टिक रिग्रेशन को प्रशिक्षित करने का एक तरीका स्टोचस्टिक ग्रेडिएंट डीसेंट का उपयोग करके है, जो स्किटिट-लर्न को एक इंटरफ़ेस प्रदान करता है।

मैं जो करना चाहूंगा, वह स्किट-लर्न का SGDClassifier लेगा और यहां लॉजिस्टिक रिग्रेशन के समान है । हालाँकि, मुझे कुछ मशीन सीखने की वृद्धि याद आ रही है, क्योंकि मेरे स्कोर समकक्ष नहीं हैं।

यह मेरा वर्तमान कोड है। मुझे SGDClassifier में क्या याद आ रहा है जो लॉजिस्टिक रिग्रेशन के समान परिणाम देगा?

from sklearn import datasets
from sklearn.linear_model import LogisticRegression
from sklearn.linear_model import SGDClassifier
import numpy as np
import pandas as pd
from sklearn.cross_validation import KFold
from sklearn.metrics import accuracy_score

# Note that the iris dataset is available in sklearn by default.
# This data is also conveniently preprocessed.
iris = datasets.load_iris()
X = iris["data"]
Y = iris["target"]

numFolds = 10
kf = KFold(len(X), numFolds, shuffle=True)

# These are "Class objects". For each Class, find the AUC through
# 10 fold cross validation.
Models = [LogisticRegression, SGDClassifier]
params = [{}, {"loss": "log", "penalty": "l2"}]
for param, Model in zip(params, Models):
    total = 0
    for train_indices, test_indices in kf:

        train_X = X[train_indices, :]; train_Y = Y[train_indices]
        test_X = X[test_indices, :]; test_Y = Y[test_indices]

        reg = Model(**param)
        reg.fit(train_X, train_Y)
        predictions = reg.predict(test_X)
        total += accuracy_score(test_Y, predictions)
    accuracy = total / numFolds
    print "Accuracy score of {0}: {1}".format(Model.__name__, accuracy)

मेरा आउटपुट:

Accuracy score of LogisticRegression: 0.946666666667
Accuracy score of SGDClassifier: 0.76

Comments

एक प्रश्न और एक अवलोकन: बार-बार चलने पर आपके एसईसीसी की सटीकता कितनी स्थिर है? दो एल्गोरिदम समतुल्य नहीं हैं और जरूरी नहीं कि वे एक ही डेटा दिए गए एक ही सटीकता का उत्पादन करेंगे। व्यावहारिक रूप से आप युगांतर और या अधिगम के लिए सीखने की दर को बदलने की कोशिश कर सकते हैं। परे कि आप SGD के लिए सुविधाओं को सामान्य करने की कोशिश कर सकते हैं।

— image_doctor 10

इसलिए, मैंने बार-बार चलने वाले लोड पर SGD का परीक्षण नहीं किया क्योंकि ऊपर 10 गुना क्रॉस सत्यापन का उपयोग करता है; मेरे लिए यह पर्याप्त है।

— hlin117

क्या आप मुझे समझा सकते हैं कि ये एल्गोरिदम कैसे समतुल्य हैं? यदि मैं यहाँ SGDClassifier को देखता हूँ, तो यह उल्लेख करता है कि "'लॉग' लॉस लॉजिस्टिक रिग्रेशन, एक प्रायिकफर्टिफायर एम्पलीफायर देता है।" मेरा मानना ​​है कि मेरी मशीन सीखने के ज्ञान में एक अंतर है।

— hlin117

कार्यान्वयन के एक विस्तृत अध्ययन के बिना मुझे नहीं लगता कि मैं इस बारे में विशिष्ट हो सकता हूं कि वे समान क्यों नहीं हैं, लेकिन एक अच्छा सुराग कि वे समकक्ष नहीं हैं प्रत्येक विधि के लिए परिणाम काफी भिन्न होते हैं। मेरा अनुमान यह होगा कि इसका उपयोग प्रत्येक में प्रयुक्त अनुमान विधियों के अभिसरण गुणों के साथ करना है।

— image_doctor

ये एल्गोरिदम अलग हैं क्योंकि लॉजिस्टिक रिग्रेशन ढाल डिसेंट का उपयोग करता है जहां स्टोचस्टिक ग्रेडिएंट डीसेंट स्टोचैस्टिक ग्रेडिएंट डीसेंट का उपयोग करता है। पूर्व का अभिसरण अधिक कुशल होगा और बेहतर परिणाम देगा। हालाँकि, जैसा कि डेटा सेट का आकार बढ़ता है, SGDC को लॉजिस्टिक रिग्रेशन की सटीकता का दृष्टिकोण रखना चाहिए। जीडी के लिए मापदंडों का मतलब है कि यह अलग-अलग चीजों के लिए है, जो कि SGD के लिए मापदंडों से अलग है, इसलिए आपको इन्हें थोड़ा समायोजित करने की कोशिश करनी चाहिए। मेरा सुझाव है कि (घटते हुए) साज़ की दरों के साथ खेलना थोड़ा बेहतर होगा और बेहतर अभिसरण प्राप्त करने की कोशिश करेंगे क्योंकि यह थोड़ा जोर दे सकता है।

— AN6U5

Answer 1

पुनरावृति संख्या के बारे में टिप्पणियां हाजिर हैं। डिफ़ॉल्ट SGDClassifier n_iterका 5अर्थ है कि आप 5 * num_rowsवजन अंतरिक्ष में कदम रखते हैं। अंगूठे का sklearn नियम ~ 1 लाख ठेठ डेटा के लिए कदम दूर है। अपने उदाहरण के लिए, बस इसे 1000 पर सेट करें और यह पहले सहिष्णुता तक पहुंच सकता है। आपकी सटीकता कम है SGDClassifierक्योंकि यह सहिष्णुता से पहले पुनरावृति सीमा को मार रहा है, इसलिए आप "शुरुआती रोक" हैं

आपके कोड को मैं जल्दी और गंदे तरीके से संशोधित करता हूं:

# Added n_iter here
params = [{}, {"loss": "log", "penalty": "l2", 'n_iter':1000}]

for param, Model in zip(params, Models):
    total = 0
    for train_indices, test_indices in kf:
        train_X = X[train_indices, :]; train_Y = Y[train_indices]
        test_X = X[test_indices, :]; test_Y = Y[test_indices]
        reg = Model(**param)
        reg.fit(train_X, train_Y)
        predictions = reg.predict(test_X)
        total += accuracy_score(test_Y, predictions)

    accuracy = total / numFolds
    print "Accuracy score of {0}: {1}".format(Model.__name__, accuracy)

Accuracy score of LogisticRegression: 0.96
Accuracy score of SGDClassifier: 0.96

Answer 2

SGDClassifier, जैसा कि नाम से पता चलता है, इसके अनुकूलन एल्गोरिथ्म के रूप में स्टोचस्टिक ग्रेडिएंट वंश का उपयोग करता है।

यदि आप Sklearn में LogisiticRegression के कार्यान्वयन को देखते हैं तो पाँच अनुकूलन तकनीकें (सॉल्वर) प्रदान की जाती हैं और डिफ़ॉल्ट रूप से यह 'लिब्लाइन' है जो जुटने के लिए कोऑर्डिनेट डिसेंट (CD) का उपयोग करती है।

पुनरावृत्तियों, अनुकूलन, नियमितीकरण के प्रकार (दंड) और इसकी परिमाण (सी) की संख्या के अलावा अन्य भी एल्गोरिदम के प्रदर्शन को प्रभावित करते हैं।

यदि आप इसे आइरिस डेटा-सेट ट्यूनिंग पर चला रहे हैं तो ये सभी हाइपर-पैरामीटर महत्वपूर्ण बदलाव नहीं ला सकते हैं, लेकिन जटिल डेटा सेट के लिए वे एक सार्थक भूमिका निभाते हैं।

अधिक के लिए, आप Sklearn लॉजिस्टिक रिग्रेशन डॉक्यूमेंटेशन का उल्लेख कर सकते हैं ।

Answer 3

आपको SGDClassifier के लिए "अल्फ़ा" हाइपरपरमीटर के लिए एक ग्रिड खोज भी करनी चाहिए। यह स्पष्ट रूप से स्केलेरन प्रलेखन में उल्लिखित है और मेरे अनुभव से सटीकता पर बड़ा प्रभाव पड़ता है। दूसरा हाइपरपरमीटर आपको देखना चाहिए "n_iter" - हालांकि मैंने अपने डेटा के साथ एक छोटा प्रभाव देखा।

Answer 4

TL; DR : आप अल्फा और n_iter (या max_iter ) का ग्रिड निर्दिष्ट कर सकते हैं और SGDClassifier पर हाइपर-ऑप्टिमाइज़ेशन के लिए parfit का उपयोग कर सकते हैं

मेरे सहकर्मी, विनय पटोला ने, हाउस्ट क्लासिफायर प्रदर्शन के साथ-साथ पैरिफिट का उपयोग करके लॉजिस्टिक रिग्रेशन बनाने के लिए एक उत्कृष्ट ब्लॉग पोस्ट लिखी ।

Parfit एक हाइपर-पैरामीटर ऑप्टिमाइज़ेशन पैकेज है, जिसका उपयोग उन्होंने उन मापदंडों के उचित संयोजन को खोजने के लिए किया है जो SGDClassifier को ऑप्टिमाइज़ करने के साथ-साथ लॉजिस्टिक रिग्रेशन को उनके उदाहरण के डेटा पर बहुत कम समय में सेट करने के लिए ऑप्टिमाइज़ करते हैं।

सारांश में, SGDClassifier के लिए दो प्रमुख पैरामीटर अल्फा और n_iter हैं । विनय को सीधे उद्धृत करने के लिए:

Sk_l में n_iter डिफ़ॉल्ट रूप से कोई भी नहीं है। हम इसे यहां पर्याप्त रूप से बड़ी राशि (1000) में स्थापित कर रहे हैं। N_iter के लिए एक वैकल्पिक पैरामीटर, जिसे हाल ही में जोड़ा गया है, max_iter है। एक ही सलाह को max_iter के लिए आवेदन करना चाहिए।

अल्फा हाइपर-पैरामीटर एक दोहरे उद्देश्य को पूरा करता है। यह एक नियमितीकरण पैरामीटर और डिफ़ॉल्ट अनुसूची के तहत प्रारंभिक सीखने की दर दोनों है। इसका मतलब यह है कि, लॉजिस्टिक रिग्रेशन गुणांक को नियमित करने के अलावा, मॉडल का उत्पादन अल्फा और एपोच की संख्या (n_iter) के बीच एक इंटरैक्शन पर निर्भर करता है जो फिटिंग रूटीन करता है। विशेष रूप से, चूंकि अल्फा बहुत छोटा हो जाता है, धीमी गति से सीखने की दर की भरपाई के लिए n_iter को बढ़ाया जाना चाहिए। यही कारण है कि अल्फ़ाज़ की एक विस्तृत श्रृंखला में खोज करते समय n_iter को पर्याप्त रूप से बड़े, जैसे 1000, को निर्दिष्ट करना सुरक्षित (लेकिन धीमा) है।