scikit-learn
Classification

Utilisation de machines à vecteurs de support

Les machines à vecteurs de support sont une famille d'algorithmes qui tentent de faire passer un hyperplan (éventuellement de grande dimension) entre deux ensembles de points étiquetés, de sorte que la distance des points par rapport au plan est optimale dans un certain sens. Les SVM peuvent être utilisés pour la classification ou la régression (correspondant respectivement à sklearn.svm.SVC et à sklearn.svm.SVR ).

Exemple:

Supposons que nous travaillions dans un espace 2D. Tout d'abord, nous créons des données:

import numpy as np

Maintenant, nous créons x et 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

Notez que x est composé de deux gaussiennes: une centrée autour de (0, 0) et une centrée autour de (1, 1) .

Pour construire un classificateur, on peut utiliser:

from sklearn import svm

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

Vérifions la prédiction pour (0, 0) :

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

La prédiction est que la classe est 0.

Pour la régression, nous pouvons faire de même:

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

RandomForestClassifier

Une forêt aléatoire est un méta-estimateur qui correspond à un certain nombre de classificateurs d'arbres de décision sur divers sous-échantillons du jeu de données et utilise la moyenne pour améliorer la précision prédictive et le sur-ajustement du contrôle.

Un exemple d'utilisation simple:

Importer:

from sklearn.ensemble import RandomForestClassifier

Définir les données de train et les données cibles:

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

Les valeurs dans la target représentent l'étiquette que vous souhaitez prédire.

Initier un objet RandomForest et effectuer un apprentissage (ajustement):

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

Prédire:

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

Analyse des rapports de classification

Construisez un rapport de texte montrant les principales métriques de classification, y compris la précision et le rappel , le score f1 (la moyenne harmonique de précision et le rappel) et le support (le nombre d'observations de cette classe dans l'ensemble d'apprentissage).

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

Sortie -

         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 pour la classification. Le classificateur à graduation est un ensemble additif d'un modèle de base dont l'erreur est corrigée par itérations successives (ou étapes) par l'ajout d'arbres de régression qui corrigent les résidus (l'erreur de l'étape précédente).

Importer:

from sklearn.ensemble import GradientBoostingClassifier

Créer des données de classification de jouets

from sklearn.datasets import load_iris

iris_dataset = load_iris()

X, y = iris_dataset.data, iris_dataset.target

Partageons ces données en un ensemble de formation et de 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)

Instanciez un modèle GradientBoostingClassifier utilisant les paramètres par défaut.

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

Laissez-nous le marquer sur l'ensemble de test

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

Par défaut, il y a 100 estimateurs construits

>>> gbc.n_estimators
100

Cela peut être contrôlé en définissant n_estimators sur une valeur différente pendant le temps d'initialisation.

Un arbre de décision

Un arbre de décision est un classificateur qui utilise une séquence de règles verbeuses (comme a> 7) qui peuvent être facilement comprises.

L'exemple ci-dessous forme un classificateur d'arbre de décision à l'aide de trois vecteurs de caractéristiques de longueur 3, puis prédit le résultat pour un quatrième vecteur d'entité encore inconnu, appelé vecteur de 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

La sortie peut être visualisée en utilisant:

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

Classification à l'aide de la régression logistique

Dans LR Classifier, les probabilités décrivant les résultats possibles d'un seul essai sont modélisées en utilisant une fonction logistique. Il est implémenté dans la bibliothèque linear_model

from sklearn.linear_model import LogisticRegression

L'implémentation de sklearn LR peut s'adapter à une régression logistique binaire, un contre un ou multinomiale avec une régularisation facultative L2 ou L1. Par exemple, considérons une classification binaire sur un exemple de jeu de données sklearn

from sklearn.datasets import make_hastie_10_2

X,y = make_hastie_10_2(n_samples=1000)

Où X est un n_samples X 10 et y les étiquettes cibles -1 ou +1.

Utiliser la séparation des tests de train pour diviser les données d'entrée en jeux de formation et de 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'utilisation du classificateur LR est similaire à d'autres exemples

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

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

Utiliser la matrice de confusion pour visualiser les résultats

from sklearn.metrics import confusion_matrix

confusion_matrix(predicted, labels_test)