scikit-learn
Klasyfikacja

Korzystanie z maszyn wektorowych wsparcia

Maszyny wektorów nośnych to rodzina algorytmów próbujących przekazać hiperpłaszczyznę (być może o wysokim wymiarze) między dwoma oznaczonymi zestawami punktów, tak że odległość punktów od płaszczyzny jest w pewnym sensie optymalna. SVM można stosować do klasyfikacji lub regresji (odpowiednio do sklearn.svm.SVC i sklearn.svm.SVR .

Przykład:

Załóżmy, że pracujemy w przestrzeni 2D. Najpierw tworzymy niektóre dane:

import numpy as np

Teraz tworzymy xiy:

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

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

Zauważ, że x składa się z dwóch Gaussów: jeden wyśrodkowany wokół (0, 0) i jeden wyśrodkowany wokół (1, 1) .

Aby zbudować klasyfikator, możemy użyć:

from sklearn import svm

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

Sprawdźmy prognozę dla (0, 0) :

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

Przewiduje się, że klasa ma wartość 0.

W przypadku regresji możemy podobnie zrobić:

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

RandomForestClassifier

Losowy las jest meta estymatorem, który pasuje do wielu klasyfikatorów drzewa decyzyjnego w różnych podpróbkach zbioru danych i wykorzystuje uśrednianie w celu poprawy dokładności predykcyjnej i kontroli nadmiernego dopasowania.

Prosty przykład użycia:

Import:

from sklearn.ensemble import RandomForestClassifier

Zdefiniuj dane pociągu i dane docelowe:

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

Wartości w target reprezentują etykietę, którą chcesz przewidzieć.

Zainicjuj obiekt RandomForest i wykonaj uczenie się (dopasowanie):

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

Przepowiadać, wywróżyć:

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

Analiza raportów klasyfikacyjnych

Zbuduj raport tekstowy pokazujący główne wskaźniki klasyfikacji, w tym precyzję i przywołanie , wynik f1 (średnia harmoniczna precyzji i przywołania) oraz wsparcie (liczba obserwacji tej klasy w zestawie treningowym).

Przykład z 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))

Wynik -

         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 do klasyfikacji. Gradient Boosting Classifier to addytywny zespół modelu podstawowego, którego błąd jest korygowany w kolejnych iteracjach (lub etapach) przez dodanie drzew regresji, które korygują reszty (błąd poprzedniego etapu).

Import:

from sklearn.ensemble import GradientBoostingClassifier

Utwórz dane klasyfikacji zabawek

from sklearn.datasets import load_iris

iris_dataset = load_iris()

X, y = iris_dataset.data, iris_dataset.target

Podzielmy te dane na zestaw szkoleniowy i testowy.

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)

Utwórz instancję modelu GradientBoostingClassifier przy użyciu domyślnych parametrów.

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

Oceńmy to na zestawie testowym

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

Domyślnie zbudowanych jest 100 estymatorów

>>> gbc.n_estimators
100

Można to kontrolować, ustawiając n_estimators na inną wartość w czasie inicjalizacji.

Drzewo decyzyjne

Drzewo decyzyjne jest klasyfikatorem, który wykorzystuje sekwencję pełnych reguł (np.> 7), które można łatwo zrozumieć.

Poniższy przykład trenuje klasyfikator drzewa decyzyjnego przy użyciu trzech wektorów cech o długości 3, a następnie przewiduje wynik dla nieznanego do tej pory czwartego wektora cech, tak zwanego wektora testowego.

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

Dane wyjściowe można wizualizować za pomocą:

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

Klasyfikacja z wykorzystaniem regresji logistycznej

W LR Classifier prawdopodobieństwo opisujące możliwe wyniki pojedynczej próby modeluje się za pomocą funkcji logistycznej. Jest zaimplementowany w bibliotece linear_model

from sklearn.linear_model import LogisticRegression

Implementacja sklearn LR może pasować do regresji logicznej binarnej, One-vs-Rest lub wielomianowej z opcjonalną regulacją L2 lub L1. Rozważmy na przykład klasyfikację binarną na przykładowym zbiorze danych sklearn

from sklearn.datasets import make_hastie_10_2

X,y = make_hastie_10_2(n_samples=1000)

Gdzie X to n_samples X 10 a y to etykiety docelowe -1 lub +1.

Użyj podziału testu pociągu, aby podzielić dane wejściowe na zestawy treningowe i testowe (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)

Korzystanie z klasyfikatora LR jest podobne do innych przykładów

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

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

Użyj matrycy pomyłek, aby wizualizować wyniki

from sklearn.metrics import confusion_matrix

confusion_matrix(predicted, labels_test)