scikit-learn
Klassificering

Använda supportvektorer

Stödvektormaskiner är en familj av algoritmer som försöker passera ett (möjligen högdimensionellt) hyperplan mellan två märkta uppsättningar av punkter, så att avståndet mellan punkterna från planet är optimalt i någon mening. SVM: er kan användas för klassificering eller regression (motsvarande sklearn.svm.SVC respektive sklearn.svm.SVR .

Exempel:

Anta att vi arbetar i ett 2D-utrymme. Först skapar vi lite data:

import numpy as np

Nu skapar vi x och 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

Observera att x är sammansatt av två Gaussians: en centrerad runt (0, 0) och en centrerad runt (1, 1) .

För att bygga en klassificering kan vi använda:

from sklearn import svm

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

Låt oss kontrollera förutsägelsen för (0, 0) :

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

Förutsägelsen är att klassen är 0.

För regression kan vi på liknande sätt göra:

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

RandomForestClassifier

En slumpmässig skog är en metauberäknare som passar ett antal beslutsträdklassificerare på olika underprover av datasatsen och använder medelvärde för att förbättra den prediktiva noggrannheten och kontrollöverpassningen.

Ett enkelt användningsexempel:

Importera:

from sklearn.ensemble import RandomForestClassifier

Definiera tågdata och måldata:

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

Värdena i target representerar den etikett du vill förutsäga.

Starta ett RandomForest-objekt och utför lärande (fit):

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

Förutspå:

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

Analysera klassificeringsrapporter

Skapa en textrapport som visar de viktigaste klassificeringsmätningarna, inklusive precision och återkallelse , f1-poäng (det harmoniska medelvärdet för precision och återkallelse) och stöd (antalet observationer av den klassen i träningsuppsättningen).

Exempelvis från sklearn docs :

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

Utgång -

         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

Gradient Boosting för klassificering. Gradient Boosting Classifier är en tillsatsensemble av en basmodell vars fel korrigeras i successiva iterationer (eller stadier) genom tillägg av Regression Trees som korrigerar resterna (felet i föregående steg).

Importera:

from sklearn.ensemble import GradientBoostingClassifier

Skapa leksaksklassificeringsdata

from sklearn.datasets import load_iris

iris_dataset = load_iris()

X, y = iris_dataset.data, iris_dataset.target

Låt oss dela upp dessa uppgifter i tränings- och tester.

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)

Instantera en GradientBoostingClassifier modell med standardparametrarna.

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

Låt oss göra det på testuppsättningen

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

Som standard är 100 uppskattare byggda

>>> gbc.n_estimators
100

Detta kan styras genom att ställa in n_estimators till ett annat värde under initialiseringstiden.

Ett beslutsträd

Ett beslutsträd är en klassificerare som använder en sekvens av ordregler (som en> 7) som lätt kan förstås.

Exemplet nedan tränar en beslutsträdklassificerare som använder tre funktionsvektorer med längd 3 och förutsäger sedan resultatet för en hittills okänd fjärde funktionsvektor, den så kallade testvektorn.

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

Output kan visualiseras med:

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

Klassificering med logistisk regression

I LR-klassificeraren modelleras han sannolikheter som beskriver de möjliga resultaten av en enda försök med en logistisk funktion. Det implementeras i biblioteket linear_model

from sklearn.linear_model import LogisticRegression

Sklearn LR-implementeringen kan passa binär, en-mot-vila eller multinomial logistisk regression med valfri L2 eller L1-regularisering. Låt oss till exempel överväga en binär klassificering i ett exempel på sklearn-datasätt

from sklearn.datasets import make_hastie_10_2

X,y = make_hastie_10_2(n_samples=1000)

Där X är ett n- n_samples X 10 array och y är måletiketterna -1 eller +1.

Använd tåg-testdelning för att dela in data i tränings- och testuppsättningar (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)

Att använda LR-klassificeraren liknar andra exempel

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

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

Använd förvirringsmatris för att visualisera resultat

from sklearn.metrics import confusion_matrix

confusion_matrix(predicted, labels_test)