scikit-learn
Classificazione

Utilizzo di macchine vettoriali di supporto

Support vector machines è una famiglia di algoritmi che tentano di passare un iperpiano (possibilmente di dimensione elevata) tra due insiemi di punti etichettati, in modo tale che la distanza dei punti dal piano sia ottimale in un certo senso. Gli SVM possono essere utilizzati per la classificazione o la regressione (corrispondenti a sklearn.svm.SVC e sklearn.svm.SVR , rispettivamente.

Esempio:

Supponiamo di lavorare in uno spazio 2D. Innanzitutto, creiamo alcuni dati:

import numpy as np

Ora creiamo x e 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

Si noti che x è composto da due gaussiani: uno centrato intorno (0, 0) e uno centrato attorno (1, 1) .

Per costruire un classificatore, possiamo usare:

from sklearn import svm

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

Controlliamo la previsione per (0, 0) :

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

La previsione è che la classe è 0.

Per la regressione, possiamo fare allo stesso modo:

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

RandomForestClassifier

Una foresta casuale è un meta-estimatore che si adatta a un certo numero di classificatori di alberi decisionali su vari sottocampioni del set di dati e utilizza la media per migliorare l'accuratezza predittiva e il controllo eccessivo.

Un semplice esempio di utilizzo:

Importare:

from sklearn.ensemble import RandomForestClassifier

Definire i dati del treno e i dati di destinazione:

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

I valori nella target rappresentano l'etichetta che si desidera prevedere.

Avvia un oggetto RandomForest ed esegui learn (fit):

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

prevedere:

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

Analizzando i rapporti di classificazione

Creare un report di testo che mostri le principali metriche di classificazione, inclusi precisione e richiamo , f1-score (la media armonica di precisione e richiamo) e supporto (il numero di osservazioni di quella classe nel set di allenamento).

Esempio dai documenti 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))

Produzione -

         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

Aumento graduale per la classificazione. Il Gradient Boosting Classifier è un insieme additivo di un modello base il cui errore viene corretto in iterazioni successive (o stadi) mediante l'aggiunta di alberi di regressione che correggono i residui (l'errore della fase precedente).

Importare:

from sklearn.ensemble import GradientBoostingClassifier

Creare alcuni dati di classificazione del giocattolo

from sklearn.datasets import load_iris

iris_dataset = load_iris()

X, y = iris_dataset.data, iris_dataset.target

Cerchiamo di suddividere questi dati in training e set di test.

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)

Crea un'istanza di un modello GradientBoostingClassifier utilizzando i parametri predefiniti.

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

Fateci segnare sul set di prova

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

Di default ci sono 100 stimatori costruiti

>>> gbc.n_estimators
100

Questo può essere controllato impostando n_estimators su un valore diverso durante il tempo di inizializzazione.

Un albero decisionale

Un albero decisionale è un classificatore che utilizza una sequenza di regole verbose (come a> 7) che può essere facilmente compresa.

L'esempio sotto forma un classificatore ad albero decisionale usando tre vettori di caratteristiche di lunghezza 3, e quindi predice il risultato per un quarto vettore di feature finora sconosciuto, il cosiddetto vettore di test.

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

L'output può essere visualizzato usando:

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

Classificazione usando la regressione logistica

In LR Classifier, le probabilità che descrivono i possibili esiti di una singola prova sono modellate usando una funzione logistica. È implementato nella libreria linear_model

from sklearn.linear_model import LogisticRegression

L'implementazione di sklearn LR può adattarsi alla regressione logistica binaria, One-vs-Rest o multinomiale con la regolarizzazione opzionale L2 o L1. Ad esempio, consideriamo una classificazione binaria su un set di dati sklearn campione

from sklearn.datasets import make_hastie_10_2

X,y = make_hastie_10_2(n_samples=1000)

Dove X è un n_samples X 10 array ey sono le etichette target -1 o +1.

Utilizzare la suddivisione del test del treno per dividere i dati di input in set di allenamento e test (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)

L'utilizzo di LR Classifier è simile ad altri esempi

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

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

Usa la matrice di confusione per visualizzare i risultati

from sklearn.metrics import confusion_matrix

confusion_matrix(predicted, labels_test)