scikit-learn
वर्गीकरण

समर्थन वेक्टर मशीनों का उपयोग करना

सपोर्ट वेक्टर मशीनें एल्गोरिदम का एक परिवार है जो अंकों के दो लेबल सेटों के बीच एक (संभवतः उच्च-आयाम) हाइपरप्लेन को पारित करने का प्रयास करता है, जैसे कि विमान से बिंदुओं की दूरी कुछ अर्थों में इष्टतम है। SVM को क्रमशः वर्गीकरण या प्रतिगमन ( sklearn.svm.SVC और sklearn.svm.SVR अनुरूप) के लिए उपयोग किया जा सकता है।

उदाहरण:

मान लीजिए हम एक 2D स्पेस में काम करते हैं। सबसे पहले, हम कुछ डेटा बनाते हैं:

import numpy as np

अब हम x और y बनाते हैं:

x0, x1 = np.random.randn(10, 2), np.random.randn(10, 2) + (1, 1)
x = np.vstack((x0, x1))

y = [0] * 10 + [1] * 10

ध्यान दें कि x दो गाऊसी से बना है: एक के आसपास केंद्रित (0, 0) , और एक के आसपास केंद्रित (1, 1) ।

एक क्लासिफायरियर बनाने के लिए, हम उपयोग कर सकते हैं:

from sklearn import svm

svm.SVC(kernel='linear').fit(x, y)

चलो (0, 0) के लिए भविष्यवाणी की जाँच करें:

>>> svm.SVC(kernel='linear').fit(x, y).predict([[0, 0]])
array([0])

भविष्यवाणी यह है कि वर्ग 0 है।

प्रतिगमन के लिए, हम इसी तरह कर सकते हैं:

svm.SVR(kernel='linear').fit(x, y)

RandomForestClassifier

एक यादृच्छिक वन एक मेटा अनुमानक है जो डेटासेट के विभिन्न उप-नमूनों पर कई निर्णय ट्री क्लासिफायर को फिट करता है और पूर्वानुमान की सटीकता में सुधार करने और ओवर-फिटिंग को नियंत्रित करने के लिए औसत का उपयोग करता है।

एक सरल उपयोग उदाहरण:

आयात:

from sklearn.ensemble import RandomForestClassifier

ट्रेन डेटा और लक्ष्य डेटा को परिभाषित करें:

train = [[1,2,3],[2,5,1],[2,1,7]]
target = [0,1,0]

target मान उस लेबल का प्रतिनिधित्व करते हैं जिसे आप भविष्यवाणी करना चाहते हैं।

एक RandomForest ऑब्जेक्ट आरंभ करें और सीखें (फिट):

rf = RandomForestClassifier(n_estimators=100)
rf.fit(train, target)

भविष्यवाणी:

test = [2,2,3]
predicted = rf.predict(test)

वर्गीकरण रिपोर्ट का विश्लेषण

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

sklearn डॉक्स से उदाहरण:

from sklearn.metrics import classification_report
y_true = [0, 1, 2, 2, 2]
y_pred = [0, 0, 2, 2, 1]
target_names = ['class 0', 'class 1', 'class 2']
print(classification_report(y_true, y_pred, target_names=target_names))

आउटपुट -

         precision    recall  f1-score   support

class 0       0.50      1.00      0.67         1
class 1       0.00      0.00      0.00         1
class 2       1.00      0.67      0.80         3

avg / total   0.70      0.60      0.61         5

GradientBoostingClassifier

वर्गीकरण के लिए धीरे-धीरे बूस्टिंग । ग्रैडिएंट बूस्टिंग क्लासिफायर एक बेस मॉडल का एक additive पहनावा है जिसकी त्रुटि प्रतिगमन पेड़ों के अतिरिक्त क्रमिक पुनरावृत्तियों (या चरणों) में ठीक की जाती है जो अवशिष्ट (पिछले चरण की त्रुटि) को ठीक करती है।

आयात:

from sklearn.ensemble import GradientBoostingClassifier

कुछ खिलौना वर्गीकरण डेटा बनाएँ

from sklearn.datasets import load_iris

iris_dataset = load_iris()

X, y = iris_dataset.data, iris_dataset.target

आइए हम इस डेटा को प्रशिक्षण और परीक्षण सेट में विभाजित करें।

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=0)

डिफ़ॉल्ट पैरामीटर का उपयोग करके एक GradientBoostingClassifier मॉडल को इंस्टेंट करें।

gbc = GradientBoostingClassifier()
gbc.fit(X_train, y_train)

आइए हम इसे टेस्ट सेट पर स्कोर करते हैं

# We are using the default classification accuracy score
>>> gbc.score(X_test, y_test)
1

डिफ़ॉल्ट रूप से 100 अनुमानक निर्मित होते हैं

>>> gbc.n_estimators
100

यह प्रारंभ के समय के दौरान n_estimators को एक अलग मान पर सेट करके नियंत्रित किया जा सकता है।

एक निर्णय वृक्ष

डिसीजन ट्री एक क्लासिफायर है जो क्रिया नियमों के अनुक्रम का उपयोग करता है (जैसे a> 7) जिसे आसानी से समझा जा सकता है।

नीचे दिए गए उदाहरण में 3 की लंबाई वाले तीन फ़ीचर वैक्टर का उपयोग करके एक निर्णय ट्री क्लासिफ़ायर ट्रेन किया गया है, और फिर एक अज्ञात चौथे फीचर वेक्टर, तथाकथित टेस्ट वेक्टर के लिए परिणाम की भविष्यवाणी करता है।

from sklearn.tree import DecisionTreeClassifier

# Define training and target set for the classifier
train = [[1,2,3],[2,5,1],[2,1,7]]
target = [10,20,30]

# Initialize Classifier. 
# Random values are initialized with always the same random seed of value 0 
# (allows reproducible results)
dectree = DecisionTreeClassifier(random_state=0)
dectree.fit(train, target)

# Test classifier with other, unknown feature vector
test = [2,2,3]
predicted = dectree.predict(test)

print predicted

आउटपुट का उपयोग करके कल्पना की जा सकती है:

import pydot
import StringIO

dotfile = StringIO.StringIO()
tree.export_graphviz(dectree, out_file=dotfile)
(graph,)=pydot.graph_from_dot_data(dotfile.getvalue())
graph.write_png("dtree.png")
graph.write_pdf("dtree.pdf")

लॉजिस्टिक रिग्रेशन का उपयोग कर वर्गीकरण

एलआर क्लासिफायर में, वह एक एकल परीक्षण के संभावित परिणामों का वर्णन करने वाली संभावनाओं को एक लॉजिस्टिक फ़ंक्शन का उपयोग करके मॉडलिंग करता है। यह linear_model लाइब्रेरी में लागू किया गया है

from sklearn.linear_model import LogisticRegression

स्केलेर एलआर कार्यान्वयन बाइनरी, वन-बनाम- रेस्ट, या वैकल्पिक एल 2 या एल 1 नियमितीकरण के साथ बहुराष्ट्रीय लॉजिस्टिक रिग्रेशन फिट कर सकता है। उदाहरण के लिए, आइए हम नमूने के स्केलेरियन डेटासेट पर एक द्विआधारी वर्गीकरण पर विचार करें

from sklearn.datasets import make_hastie_10_2

X,y = make_hastie_10_2(n_samples=1000)

जहाँ X एक n_samples X 10 सरणी है और y लक्ष्य लेबल -1 या +1 है।

प्रशिक्षण और परीक्षण सेटों में इनपुट डेटा को विभाजित करने के लिए ट्रेन-टेस्ट विभाजन का उपयोग करें (70% -30%)

from sklearn.model_selection import train_test_split 
#sklearn.cross_validation in older scikit versions

data_train, data_test, labels_train, labels_test = train_test_split(X,y, test_size=0.3)

LR क्लासिफायर का उपयोग करना अन्य उदाहरणों के समान है

# Initialize Classifier. 
LRC = LogisticRegression()
LRC.fit(data_train, labels_train)

# Test classifier with the test data
predicted = LRC.predict(data_test)

परिणामों की कल्पना करने के लिए भ्रम मैट्रिक्स का उपयोग करें

from sklearn.metrics import confusion_matrix

confusion_matrix(predicted, labels_test)