scikit-learn
Classificatie

Ondersteuning van vectormachines

Ondersteuning van vectormachines is een familie van algoritmen die een (mogelijk hoog-dimensionaal) hypervlak proberen te passeren tussen twee gelabelde sets van punten, zodat de afstand van de punten tot het vlak in zekere zin optimaal is. SVM's kunnen worden gebruikt voor classificatie of regressie (overeenkomend met respectievelijk sklearn.svm.SVC en sklearn.svm.SVR .

Voorbeeld:

Stel dat we in een 2D-ruimte werken. Eerst maken we enkele gegevens:

import numpy as np

Nu maken we x en 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

Merk op dat x bestaat uit twee Gaussianen: één gecentreerd rond (0, 0) en één gecentreerd rond (1, 1) .

Om een classifier te bouwen, kunnen we gebruiken:

from sklearn import svm

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

Laten we de voorspelling voor (0, 0) bekijken :

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

De voorspelling is dat de klasse 0 is.

Voor regressie kunnen we op dezelfde manier doen:

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

RandomForestClassifier

Een willekeurig forest is een metaschatter die past bij een aantal beslissingsboomclassificaties in verschillende submonsters van de gegevensset en gebruik middeling om de voorspellende nauwkeurigheid te verbeteren en overaanpassing te regelen.

Een eenvoudig gebruiksvoorbeeld:

Importeren:

from sklearn.ensemble import RandomForestClassifier

Definieer treingegevens en doelgegevens:

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

De waarden in target vertegenwoordigen het label dat u wilt voorspellen.

Start een RandomForest-object en voer leren uit (fit):

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

Voorspellen:

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

Classificatierapporten analyseren

Stel een tekstrapport samen met de belangrijkste classificatiestatistieken, inclusief de precisie en recall , f1-score (het harmonische gemiddelde van precisie en recall) en ondersteuning (het aantal observaties van die klasse in de trainingsset).

Voorbeeld uit sklearn documenten :

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

Uitgang -

         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 voor classificatie. De Gradient Boosting Classifier is een additief ensemble van een basismodel waarvan de fout wordt gecorrigeerd in opeenvolgende iteraties (of fasen) door de toevoeging van regressiebomen die de residuen corrigeren (de fout van de vorige fase).

Importeren:

from sklearn.ensemble import GradientBoostingClassifier

Maak wat speelgoedclassificatiegegevens

from sklearn.datasets import load_iris

iris_dataset = load_iris()

X, y = iris_dataset.data, iris_dataset.target

Laten we deze gegevens opsplitsen in trainings- en testset.

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)

Instantiate een GradientBoostingClassifier model met behulp van de standaard params.

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

Laten we het scoren op de testset

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

Standaard zijn er 100 schatters gebouwd

>>> gbc.n_estimators
100

Dit kan worden geregeld door n_estimators op een andere waarde in te stellen tijdens de initialisatietijd.

Een beslissingsboom

Een beslissingsboom is een classificator die een reeks uitgebreide regels gebruikt (zoals een> 7) die gemakkelijk kan worden begrepen.

Het onderstaande voorbeeld traint een beslissingsboomclassificator met behulp van drie kenmerkvectoren van lengte 3, en voorspelt vervolgens het resultaat voor een tot nu toe onbekende vierde kenmerkvector, de zogenaamde testvector.

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

Uitvoer kan worden gevisualiseerd met:

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

Classificatie met behulp van logistieke regressie

In LR Classifier worden de kansen die de mogelijke uitkomsten van een enkele proef beschrijven, gemodelleerd met behulp van een logistieke functie. Het is geïmplementeerd in de linear_model bibliotheek

from sklearn.linear_model import LogisticRegression

De LR-implementatie van sklearn past bij binaire, One-vs- Rest of multinomiale logistieke regressie met optionele L2- of L1-regularisatie. Laten we bijvoorbeeld eens kijken naar een binaire classificatie in een voorbeeldset met sklearn-gegevens

from sklearn.datasets import make_hastie_10_2

X,y = make_hastie_10_2(n_samples=1000)

Waar X een n_samples X 10 array is en y de n_samples X 10 -1 of +1 is.

Gebruik train-test split om de invoergegevens te verdelen in trainings- en testsets (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)

Het gebruik van de LR Classifier is vergelijkbaar met andere voorbeelden

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

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

Gebruik Verwarringmatrix om resultaten te visualiseren

from sklearn.metrics import confusion_matrix

confusion_matrix(predicted, labels_test)